The Atari Compendium/The Atari Compendium (Toad Computers) (1994).iso/files/prgtools/programm.ing/cpp114.zoo/src/utils.c

C/C++ Source or Header | 1995-01-20 | 4.6 KB | 216 lines

/*---------------------------------------------------------------------*\
|                                    |
| CPP -- a stand-alone C preprocessor                    |
| Copyright (c) 1993-95 Hacker Ltd.        Author: Scott Bigham    |
|                                    |
| Permission is granted to anyone to use this software for any purpose    |
| on any computer system, and to redistribute it freely, with the    |
| following restrictions:                        |
| - No charge may be made other than reasonable charges for repro-    |
|     duction.                                |
| - Modified versions must be clearly marked as such.            |
| - The author is not responsible for any harmful consequences of    |
|     using this software, even if they result from defects therein.    |
|                                    |
| utils.c -- assorted utility routines                    |
\*---------------------------------------------------------------------*/

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#if defined(__STDC__) || defined(__SOZOBONC__) || defined(__SOZOBONX__)
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#include "global.h"
#include "ztype.h"

#define EM_ERROR  0
#define EM_WARN   1
#define EM_FATAL  2
#define EM_BUGCHK 3

#ifdef __STDC__
#define __EM_fmt__ (const char *fmt, ...)
#else
# if defined(__SOZOBONC__) || defined(__SOZOBONX__)
# define __EM_fmt__ (fmt) char *fmt;
# else
# define __EM_fmt__ (va_alist) va_dcl
# endif
#endif

extern int nerrs;

static char *em_text[] =
{"", " warning:", " FATAL:", " compiler bug:"};

/* em_header() -- add file and line number information to error message */
static void em_header(n)
  int n;
{
  if (cur_file)
    fprintf(stderr, "In file \"%s\" (%lu):%s ", cur_file, this_line, em_text[n]);
  else
    fprintf(stderr, "%s:%s ", argv0, em_text[n]);
}

/* fatal() -- print an error message and punt */
void fatal __EM_fmt__
{
  va_list ap;

  em_header(EM_FATAL);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(1);
}

/*
   bugchk() -- similar to fatal(), but reserved for flagging compiler bugs
*/
void bugchk __EM_fmt__
{
  va_list ap;

  em_header(EM_BUGCHK);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(1);
}

/* error() -- print an error message and bump the error counter */
void error __EM_fmt__
{
  va_list ap;

  em_header(EM_ERROR);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  nerrs++;
}

/* warning() -- print an error/informational message */
void warning __EM_fmt__
{
  va_list ap;

  em_header(EM_WARN);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
}

/* message() -- print an informational message */
void message __EM_fmt__
{
  va_list ap;

  em_header(EM_ERROR);
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
}

/* mallok() -- a paranoia wrapper around malloc() */
void *mallok(n)
  size_t n;
{
  register void *t = malloc(n);

  if (!t)
    fatal("cannot get %lu bytes", (unsigned long)n);
  return t;
}

/* reallok() -- a paranoia wrapper around realloc() */
void *reallok(t, n)
  void *t;
  size_t n;
{
  register void *u = realloc(t, n);

  if (!u)
    fatal("cannot get %lu bytes", (unsigned long)n);
  return u;
}

/*
   copy_filename() -- return malloc()'ed memory containing the first |len|
   characters of |fnam|, or all of |fnam| if |len==0|
*/
char *copy_filename(fnam, len)
  char *fnam;
  int len;
{
  char *newfnam;
  register char *s = fnam, *t;
  register int i;

  if (len == 0)
    len = strlen(fnam);
  t = newfnam = mallok(len + 1);
  for (i = 0; i < len; s++, t++, i++)
    *t = ((*s == '/' || *s == '\\') ? PATH_SEP : *s);
  *t = '\0';
  return newfnam;
}

#ifndef __GNUC__
/* strdup() -- return malloc()'ed space containing a copy of |s| */
char *strdup(s)
  register const char *s;
{
  return strcpy((char *)mallok(strlen(s) + 1), s);
}

#endif

/*
   xfopen() -- like fopen(), except that setvbuf() is called to increase the
   buffer size
*/
FILE *xfopen(fnam, mode)
  const char *fnam, *mode;
{
  FILE *f = fopen(fnam, mode);

  if (!f)
    fatal("cannot open %s file %s", (*mode == 'r' ? "input" : "output"),
      fnam);
  if (setvbuf(f, NULL, _IOFBF, NEWBUFSIZ) != 0)
    fatal("cannot get file buffer for %s", fnam);
  return f;
}

/*
   grow() -- expand buffer |*buf|, originally of length |*buflen|, to hold an
   additional |add_len| characters.  |in_ptr| is a pointer into the buffer;
   return a pointer into the new buffer with the same offset.
*/
char *grow(buf, buflen, in_ptr, add_len)
  char **buf;
  size_t *buflen;
  char *in_ptr;
  int add_len;
{
  ptrdiff_t dp = in_ptr - *buf;

  if (dp + add_len <= *buflen)
    return in_ptr;
  while (*buflen < dp + add_len)
    *buflen *= 2;
  *buf = reallok(*buf, *buflen);
  return *buf + dp;
}