ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/MISC/GNU/FUTI14AS.ZIP/TAC.C

C/C++ Source or Header | 1992-02-22 | 18.6 KB | 704 lines

/* tac - concatenate and print files in reverse
   Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

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

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

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Written by Jay Lepreau ([e-mail]).
   GNU enhancements by David MacKenzie ([e-mail]). */

/* MS-DOS port (c) 1990 by Thorsten Ohl, [e-mail]
   This port is also distributed under the terms of the
   GNU General Public License as published by the
   Free Software Foundation.

   Please note that this file is not identical to the
   original GNU release, you should have received this
   code as patch to the official release.  */

#ifdef MSDOS
static char RCS_Id[] =
  "$Header: e:/gnu/fileutil/RCS/tac.c 1.4.0.3 90/09/19 12:09:16 tho Exp $";

static char Program_Id[] = "tac";
static char RCS_Revision[] = "$Revision: 1.4.0.3 $";

#define VERSION \
  "GNU %s, Version %.*s (compiled %s %s for MS-DOS)\n", Program_Id, \
  (sizeof RCS_Revision - 14), (RCS_Revision + 11), __DATE__, __TIME__

#define COPYING \
  "This is free software, distributed under the terms of the\n" \
  "GNU General Public License.  For details, see the file COPYING.\n"
#endif /* MSDOS */

/* Usage: tac [-br] [-s separator] [+before] [+regex] [+separator separator]
          [file...]

   Copy each FILE, or the standard input if none are given or when a
   FILE name of "-" is encountered, to the standard output with the
   order of the records reversed.  The records are separated by
   instances of a string, or a newline if none is given.  By default, the
   separator string is attached to the end of the record that it
   follows in the file.

   Options:
   -b, +before            The separator is attached to the beginning
                of the record that it precedes in the file.
   -r, +regex            The separator is a regular expression.
   -s, +separator separator    Use SEPARATOR as the record separator.

   To reverse a file byte by byte, use (in bash, ksh, or sh):
tac -r -s '.\|
' file */

#include <stdio.h>
#include <getopt.h>
#include <sys/types.h>
#include <signal.h>
#include "system.h"
#include "regex.h"

#ifdef STDC_HEADERS
#include <stdlib.h>
#include <errno.h>
#else
char *malloc ();
char *realloc ();

extern int errno;
#endif

/* The number of bytes per atomic read. */
#define INITIAL_READSIZE 8192

/* The number of bytes per atomic write. */
#define WRITESIZE 8192

char *mktemp ();

#ifndef _POSIX_SOURCE
off_t lseek ();
#endif

#ifdef MSDOS

#include <gnulib.h>
#include <io.h>

/* We need a static malloc (with cleanup) here, so mask off
   the one from gnulib   */
#define xmalloc _xmalloc
#define xrealloc _xrealloc

static char *_xmalloc (unsigned int n);
static char *_xrealloc (char *p, unsigned int n);

extern void main (int argc, char **argv);
static int tac (int fd, char *file);
static int tac_file (char *file);
static int tac_stdin (void );
static void output (char *start, char *past_end);
static void save_stdin (void );
static void xwrite (int desc, char *buffer, int size);
static SIGTYPE cleanup (void );

#else /* not MSDOS */

SIGTYPE cleanup ();
int tac ();
int tac_file ();
int tac_stdin ();
char *xmalloc ();
char *xrealloc ();
void output ();
void error ();
void save_stdin ();
void xwrite ();
#endif /* not MSDOS */

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

/* The string that separates the records of the file. */
char *separator;

/* If nonzero, print `separator' along with the record preceding it
   in the file; otherwise with the record following it. */
int separator_ends_record;

/* 0 if `separator' is to be matched as a regular expression;
   otherwise, the length of `separator', used as a sentinel to
   stop the search. */
int sentinel_length;

/* The length of a match with `separator'.  If `sentinel_length' is 0,
   `match_length' is computed every time a match succeeds;
   otherwise, it is simply the length of `separator'. */
int match_length;

/* The input buffer. */
char *buffer;

/* The number of bytes to read at once into `buffer'. */
unsigned read_size;

/* The size of `buffer'.  This is read_size * 2 + sentinel_length + 2.
   The extra 2 bytes allow `past_end' to have a value beyond the
   end of `buffer' and `match_start' to run off the front of `buffer'. */
unsigned buffer_size;

/* The compiled regular expression representing `separator'. */
static struct re_pattern_buffer compiled_separator;

struct option longopts[] =
{
#ifdef MSDOS
  {"copying", 0, NULL, 30},
  {"version", 0, NULL, 31},
#endif
  {"before", 0, &separator_ends_record, 0},
  {"regex", 0, &sentinel_length, 0},
  {"separator", 1, NULL, 's'},
  {NULL, 0, NULL, 0}
};

void
main (argc, argv)
     int argc;
     char **argv;
{
  char *error_message;        /* Return value from re_compile_pattern. */
  int optc, longind, errors;

  program_name = argv[0];
#ifdef MSDOS
  setmode (0, O_BINARY);
  setmode (1, O_BINARY);
#endif /* MSDOS */

  errors = 0;
  separator = "\n";
  sentinel_length = 1;
  separator_ends_record = 1;

  while ((optc = getopt_long (argc, argv, "brs:", longopts, &longind))
     != EOF)
    {
      switch (optc)
    {
    case 0:
      break;
    case 'b':
      separator_ends_record = 0;
      break;
    case 'r':
      sentinel_length = 0;
      break;
    case 's':
      separator = optarg;
      if (*separator == 0)
        error (1, 0, "separator cannot be empty");
      break;
#ifdef MSDOS
    case 30:
      fprintf (stderr, COPYING);
      exit (0);
      break;
    case 31:
      fprintf (stderr, VERSION);
      exit (0);
      break;
#endif
    default:
#ifdef MSDOS
      fprintf (stderr, "\
Usage: %s [-br] [-s separator] [+before] [+regex] [+separator separator]\n\
       [+copying] [+version] [file...]\n",
#else /* not MSDOS */
      fprintf (stderr, "\
Usage: %s [-br] [-s separator] [+before] [+regex] [+separator separator]\n\
       [file...]\n",
#endif /* not MSDOS */
           program_name);
      exit (1);
    }
    }

  if (sentinel_length == 0)
    {
      compiled_separator.allocated = 100;
#ifdef MSDOS
      compiled_separator.buffer
    = xmalloc ((size_t) compiled_separator.allocated);
#else /* not MSDOS */
      compiled_separator.buffer = xmalloc (compiled_separator.allocated);
#endif /* not MSDOS */
      compiled_separator.fastmap = xmalloc (256);
      compiled_separator.translate = 0;
      error_message = re_compile_pattern (separator, strlen (separator),
                      &compiled_separator);
      if (error_message)
    error (1, 0, "%s", error_message);
    }
  else
    match_length = sentinel_length = strlen (separator);

  read_size = INITIAL_READSIZE;
  /* A precaution that will probably never be needed. */
  while (sentinel_length * 2 >= read_size)
    read_size *= 2;
  buffer_size = read_size * 2 + sentinel_length + 2;
  buffer = xmalloc (buffer_size);
  if (sentinel_length)
    {
      strcpy (buffer, separator);
      buffer += sentinel_length;
    }
  else
    ++buffer;

  if (optind == argc)
    errors = tac_stdin ();
  else
    for (; optind < argc; ++optind)
      {
    if (strcmp (argv[optind], "-") == 0)
      errors |= tac_stdin ();
    else
      errors |= tac_file (argv[optind]);
      }

  /* Flush the output buffer. */
  output ((char *) NULL, (char *) NULL);
  exit (errors);
}

/* The name of a temporary file containing a copy of pipe input. */
char *tempfile;

/* Print the standard input in reverse, saving it to temporary
   file `tempfile' first if it is a pipe.
   Return 0 if ok, 1 if an error occurs. */

int
tac_stdin ()
{
  /* Previous values of signal handlers. */
  SIGTYPE (*sigint) (), (*sighup) (), (*sigterm) ();
  int errors;
  struct stat stats;

  /* No tempfile is needed for "tac < file".
     Use fstat instead of checking for errno == ESPIPE because
     lseek doesn't work on some special files but doesn't return an
     error, either. */
  if (fstat (0, &stats))
    {
      error (0, errno, "standard input");
      return 1;
    }
  if ((stats.st_mode & S_IFMT) == S_IFREG)
    return tac (0, "standard input");

  sigint = signal (SIGINT, SIG_IGN);
  if (sigint != SIG_IGN)
    signal (SIGINT, cleanup);
#ifdef SIGHUP
  sighup = signal (SIGHUP, SIG_IGN);
  if (sighup != SIG_IGN)
    signal (SIGHUP, cleanup);
#endif
  sigterm = signal (SIGTERM, SIG_IGN);
  if (sigterm != SIG_IGN)
    signal (SIGTERM, cleanup);
  save_stdin ();

  errors = tac_file (tempfile);

  unlink (tempfile);
  signal (SIGINT, sigint);
#ifdef SIGHUP
  signal (SIGHUP, sighup);
#endif
  signal (SIGTERM, sigterm);
  return errors;
}

#ifdef MSDOS
char template[] = "/tacXXXXXX";
char *workplate;
#else /* not MSDOS */
char template[] = "/tmp/tacXXXXXX";
char workplate[sizeof template];
#endif /* not MSDOS */

/* Make a copy of the standard input in `tempfile'. */

void
save_stdin ()
{
  int fd;
  int bytes_read;

#ifdef MSDOS
  char *p;

  if ((p = getenv ("TMP")) || (p = getenv ("TEMP")))
    {
      int len = strlen (p);
      workplate = (char *) xmalloc (sizeof (template) + len + 1);
      strcpy (workplate, p);
      p = workplate + len - 1;
      if (*p == '/' || *p == '\\')    /*  strip trailing slash */
    *p = '\0';
    }
  else
    {
      workplate = (char *) xmalloc (sizeof (template) + 2);
      strcpy (workplate, ".");
    }
  strcat (workplate, template);
#else /* not MSDOS */
  strcpy (workplate, template);
#endif /* not MSDOS */
  tempfile = mktemp (workplate);

#ifdef MSDOS
  fd = open (tempfile, O_CREAT|O_TRUNC|O_RDWR|O_BINARY, S_IWRITE|S_IREAD);
#else /* not MSDOS */
  fd = creat (tempfile, 0600);
#endif /* not MSDOS */
  if (fd == -1)
    {
      error (0, errno, "%s", tempfile);
      cleanup ();
    }

  while ((bytes_read = read (0, buffer, read_size)) > 0)
    if (write (fd, buffer, bytes_read) != bytes_read)
      {
    error (0, errno, "%s", tempfile);
    cleanup ();
      }
  close (fd);
  if (bytes_read == -1)
    {
      error (0, errno, "read error");
      cleanup ();
    }
}

/* Print FILE in reverse.
   Return 0 if ok, 1 if an error occurs. */

int
tac_file (file)
     char *file;
{
  int fd, errors;

#ifdef MSDOS
  fd = open (file, O_RDONLY|O_BINARY);
#else /* not MSDOS */
  fd = open (file, 0);
#endif /* not MSDOS */
  if (fd == -1)
    {
      error (0, errno, "%s", file);
      return 1;
    }
  errors = tac (fd, file);
  close (fd);
  return errors;
}

/* Print in reverse the file open on descriptor FD for reading FILE.
   Return 0 if ok, 1 if an error occurs. */

int
tac (fd, file)
     int fd;
     char *file;
{
  /* Pointer to the location in `buffer' where the search for
     the next separator will begin. */
  char *match_start;
  /* Pointer to one past the rightmost character in `buffer' that
     has not been printed yet. */
  char *past_end;
  unsigned saved_record_size;    /* Length of the record growing in `buffer'. */
  off_t file_pos;        /* Offset in the file of the next read. */
  /* Nonzero if `output' has not been called yet for any file.
     Only used when the separator is attached to the preceding record. */
  int first_time = 1;
  char first_char = *separator;    /* Speed optimization, non-regexp. */
  char *separator1 = separator + 1; /* Speed optimization, non-regexp. */
  int match_length1 = match_length - 1; /* Speed optimization, non-regexp. */
  struct re_registers regs;
  int errors = 0;

  /* Find the size of the input file. */
  file_pos = lseek (fd, (off_t) 0, L_XTND);
  if (file_pos < 1)
    return 0;            /* It's an empty file. */

  /* Arrange for the first read to lop off enough to leave the rest of the
     file a multiple of `read_size'.  Since `read_size' can change, this may
     not always hold during the program run, but since it usually will, leave
     it here for i/o efficiency (page/sector boundaries and all that).
     Note: the efficiency gain has not been verified. */
#ifdef MSDOS
  saved_record_size = (unsigned int) (file_pos % read_size);
#else /* not MSDOS */
  saved_record_size = file_pos % read_size;
#endif /* not MSDOS */
  if (saved_record_size == 0)
    saved_record_size = read_size;
  file_pos -= saved_record_size;
  /* `file_pos' now points to the start of the last (probably partial) block
     in the input file. */

  lseek (fd, file_pos, L_SET);
  if (read (fd, buffer, saved_record_size) != saved_record_size)
    {
      error (0, 1, "%s", file);
      return 1;
    }

#ifdef MSDOS
  /* Some loosing editors add one or more ^Z to the end of a text file and
     loosing MS-DOS devices interpret this as End Of File.  We turn them
     into spaces and print a warning message.  */
    {
      char *ctrl_z = buffer + saved_record_size - 1;
      if (*ctrl_z == '\032')
    {
      *ctrl_z = ' ';
      error (0, 0, "%s: trailing ^Z translated to space.", file);
      while (*--ctrl_z == '\032')
        *ctrl_z = ' ';
    }
    }
#endif /* MSDOS */

  match_start = past_end = buffer + saved_record_size;
  /* For non-regexp search, move past impossible positions for a match. */
  if (sentinel_length)
    match_start -= match_length1;

  for (;;)
    {
      /* Search backward from `match_start' - 1 to `buffer' for a match
     with `separator'; for speed, use strncmp if `separator' contains no
     metacharacters.
     If the match succeeds, set `match_start' to point to the start of
     the match and `match_length' to the length of the match.
     Otherwise, make `match_start' < `buffer'. */
      if (sentinel_length == 0)
    {
      int i = match_start - buffer;
      int ret;

      ret = re_search (&compiled_separator, buffer, i, i - 1, -i, ®s);
      if (ret == -1)
        match_start = buffer - 1;
      else if (ret == -2)
        {
          error (0, 0, "error in regular expression search");
          cleanup ();
        }
      else
        {
          match_start = buffer + regs.start[0];
          match_length = regs.end[0] - regs.start[0];
        }
    }
      else
    {
      /* `match_length' is constant for non-regexp boundaries. */
      while (*--match_start != first_char
         || (match_length1 && strncmp (match_start + 1, separator1,
                           match_length1)))
        /* Do nothing. */ ;
    }

      /* Check whether we backed off the front of `buffer' without finding
         a match for `separator'. */
      if (match_start < buffer)
    {
      if (file_pos == 0)
        {
          /* Hit the beginning of the file; print the remaining record. */
          output (buffer, past_end);
          return errors;
        }

      saved_record_size = past_end - buffer;
      if (saved_record_size > read_size)
        {
          /* `buffer_size' is about twice `read_size', so since
         we want to read in another `read_size' bytes before
         the data already in `buffer', we need to increase
         `buffer_size'. */
          char *newbuffer;
          int offset = sentinel_length ? sentinel_length : 1;

          read_size *= 2;
          buffer_size = read_size * 2 + sentinel_length + 2;
          newbuffer = xrealloc (buffer - offset, buffer_size) + offset;
          /* Adjust the pointers for the new buffer location.  */
          match_start += newbuffer - buffer;
          past_end += newbuffer - buffer;
          buffer = newbuffer;
        }

      /* Back up to the start of the next bufferfull of the file.  */
      if (file_pos >= read_size)
        file_pos -= read_size;
      else
        {
          read_size = (unsigned) file_pos;
          file_pos = 0;
        }
      lseek (fd, file_pos, L_SET);

      /* Shift the pending record data right to make room for the new. */
      bcopy (buffer, buffer + read_size, saved_record_size);
      past_end = buffer + read_size + saved_record_size;
      /* For non-regexp searches, avoid unneccessary scanning. */
      if (sentinel_length)
        match_start = buffer + read_size;
      else
        match_start = past_end;

      if (read (fd, buffer, read_size) != read_size)
        {
          error (0, errno, "%s", file);
          return 1;
        }
    }
      else
    {
      /* Found a match of `separator'. */
      if (separator_ends_record)
        {
          char *match_end = match_start + match_length;

          /* If this match of `separator' isn't at the end of the
             file, print the record. */
          if (first_time == 0 || match_end != past_end)
        output (match_end, past_end);
          past_end = match_end;
          first_time = 0;
        }
      else
        {
          output (match_start, past_end);
          past_end = match_start;
        }
      match_start -= match_length - 1;
    }
    }
}

/* Print the characters from START to PAST_END - 1.
   If START is NULL, just flush the buffer. */

void
output (start, past_end)
     char *start;
     char *past_end;
{
  static char buffer[WRITESIZE];
  static int bytes_in_buffer = 0;
  int bytes_to_add = past_end - start;
  int bytes_available = WRITESIZE - bytes_in_buffer;

  if (start == 0)
    {
      xwrite (1, buffer, bytes_in_buffer);
      bytes_in_buffer = 0;
      return;
    }

  /* Write out as many full buffers as possible. */
  while (bytes_to_add >= bytes_available)
    {
      bcopy (start, buffer + bytes_in_buffer, bytes_available);
      bytes_to_add -= bytes_available;
      start += bytes_available;
      xwrite (1, buffer, WRITESIZE);
      bytes_in_buffer = 0;
      bytes_available = WRITESIZE;
    }

  bcopy (start, buffer + bytes_in_buffer, bytes_to_add);
  bytes_in_buffer += bytes_to_add;
}

SIGTYPE
cleanup ()
{
  unlink (tempfile);
  exit (1);
}

void
xwrite (desc, buffer, size)
     int desc;
     char *buffer;
     int size;
{
  if (write (desc, buffer, size) != size)
    {
      error (0, errno, "write error");
      cleanup ();
    }
}


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

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

  p = malloc (n);
  if (p == 0)
    {
      error (0, 0, "virtual memory exhausted");
      cleanup ();
    }
  return p;
}

/* Change the size of memory area P to N bytes, with error checking. */

char *
xrealloc (p, n)
     char *p;
     unsigned n;
{
  p = realloc (p, n);
  if (p == 0)
    {
      error (0, 0, "virtual memory exhausted");
      cleanup ();
    }
  return p;
}