home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / cpp102 / utils.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  3.8 KB  |  186 lines
  1.  
  2. #include <stdio.h>
  3. #include <stddef.h>
  4. #include <stdlib.h>
  5. #if defined(__STDC__) || defined(__SOZOBONC__)
  6. #include <stdarg.h>
  7. #else
  8. #include <varargs.h>
  9. #endif
  10. #include "global.h"
  11. #include "ztype.h"
  12.  
  13. #define EM_ERROR  0
  14. #define EM_WARN   1
  15. #define EM_FATAL  2
  16. #define EM_BUGCHK 3
  17.  
  18. #ifdef __STDC__
  19. #define __EM_fmt__ (char *fmt, ...)
  20. #else
  21. # ifdef __SOZOBONC__
  22. # define __EM_fmt__ (fmt) char *fmt;
  23. # else
  24. # define __EM_fmt__ (va_alist) va_dcl
  25. # endif
  26. #endif
  27.  
  28. extern int nerrs;
  29.  
  30. static char *em_text[] =
  31. {"", " warning:", " FATAL:", " compiler bug:"};
  32.  
  33. /* em_header() -- add file and line number information to error message */
  34. static void em_header(n)
  35.   int n;
  36. {
  37.   if (cur_file)
  38.     fprintf(stderr, "In file \"%s\" (%lu):%s ", cur_file, this_line, em_text[n]);
  39.   else
  40.     fprintf(stderr, "%s:%s ", argv0, em_text[n]);
  41. }
  42.  
  43. /* fatal() -- print an error message and punt */
  44. void fatal __EM_fmt__
  45. {
  46.   va_list ap;
  47.     em_header(EM_FATAL);
  48.     va_start(ap, fmt);
  49.     vfprintf(stderr, fmt, ap);
  50.     va_end(ap);
  51.     fputc('\n', stderr);
  52.     exit(1);
  53. }
  54.  
  55. /*
  56.    bugchk() -- similar to fatal(), but reserved for flagging compiler bugs
  57. */
  58. void bugchk __EM_fmt__
  59. {
  60.   va_list ap;
  61.     em_header(EM_BUGCHK);
  62.     va_start(ap, fmt);
  63.     vfprintf(stderr, fmt, ap);
  64.     va_end(ap);
  65.     fputc('\n', stderr);
  66.     exit(1);
  67. }
  68.  
  69. /* error() -- print an error message and bump the error counter */
  70. void error __EM_fmt__
  71. {
  72.   va_list ap;
  73.     em_header(EM_ERROR);
  74.     va_start(ap, fmt);
  75.     vfprintf(stderr, fmt, ap);
  76.     va_end(ap);
  77.     fputc('\n', stderr);
  78.     nerrs++;
  79. }
  80.  
  81. /* warning() -- print an error/informational message */
  82. void warning __EM_fmt__
  83. {
  84.   va_list ap;
  85.     em_header(EM_WARN);
  86.     va_start(ap, fmt);
  87.     vfprintf(stderr, fmt, ap);
  88.     va_end(ap);
  89.     fputc('\n', stderr);
  90. }
  91.  
  92. /* mallok() -- a paranoia wrapper around malloc() */
  93. void *mallok(n)
  94.   size_t n;
  95. {
  96.   void *t = malloc(n);
  97.  
  98.   if (!t)
  99.     fatal("cannot get %lu bytes", (unsigned long)n);
  100.   return t;
  101. }
  102.  
  103. /* reallok() -- a paranoia wrapper around realloc() */
  104. void *reallok(t, n)
  105.   void *t;
  106.   size_t n;
  107. {
  108.   void *u = realloc(t, n);
  109.  
  110.   if (!u)
  111.     fatal("cannot get %lu bytes", (unsigned long)n);
  112.   return u;
  113. }
  114.  
  115. /*
  116.    copy_filename() -- return malloc()'ed memory containing the first |len|
  117.    characters of |fnam|, or all of |fnam| if |len==0|
  118. */
  119. char *copy_filename(fnam, len)
  120.   char *fnam;
  121.   int len;
  122. {
  123.   char *newfnam;
  124.   register char *s = fnam, *t;
  125.   register int i;
  126.  
  127.   if (len == 0)
  128.     len = strlen(fnam);
  129.   t = newfnam = mallok(len + 1);
  130.   for (i = 0; i < len; s++, t++, i++)
  131.     *t = ((*s == '/' || *s == '\\') ? PATH_SEP : *s);
  132.   *t = 0;
  133.   return newfnam;
  134. }
  135.  
  136. #ifndef __GNUC__
  137. /* strdup() -- return malloc()'ed space containing a copy of |s| */
  138. char *strdup(s)
  139.   char *s;
  140. {
  141.   char *t = (char *)mallok(strlen(s) + 1);
  142.  
  143.   strcpy(t, s);
  144.   return t;
  145. }
  146.  
  147. #endif
  148.  
  149. /*
  150.    xfopen() -- like fopen(), except that setvbuf() is called to increase the
  151.    buffer size
  152. */
  153. FILE *xfopen(fnam, mode)
  154.   char *fnam, *mode;
  155. {
  156.   FILE *f = fopen(fnam, mode);
  157.  
  158.   if (!f)
  159.     fatal("cannot open %s file %s", (*mode == 'r' ? "input" : "output"),
  160.       fnam);
  161.   if (setvbuf(f, NULL, _IOFBF, NEWBUFSIZ) != 0)
  162.     fatal("cannot get file buffer for %s", fnam);
  163.   return f;
  164. }
  165.  
  166. /*
  167.    grow() -- expand buffer |*buf|, originally of length |*buflen|, to hold an
  168.    additional |add_len| characters.  |in_ptr| is a pointer into the buffer;
  169.    return a pointer into the new buffer with the same offset.
  170. */
  171. char *grow(buf, buflen, in_ptr, add_len)
  172.   char **buf;
  173.   size_t *buflen;
  174.   char *in_ptr;
  175.   int add_len;
  176. {
  177.   ptrdiff_t dp = in_ptr - *buf;
  178.  
  179.   if (dp + add_len <= *buflen)
  180.     return in_ptr;
  181.   while (*buflen < dp + add_len)
  182.     *buflen *= 2;
  183.   *buf = reallok(*buf, *buflen);
  184.   return *buf + dp;
  185. }
  186.