x2p/util.c

   1 /* $RCSfile: util.c,v $$Revision: 4.1 $$Date: 92/08/07 18:29:29 $
   2  *
   3  *    Copyright (c) 1991-1997, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  * $Log:        util.c,v $
   9  */
  10
  11 #include "EXTERN.h"
  12 #include "a2p.h"
  13 #include "INTERN.h"
  14 #include "util.h"
  15
  16 #ifdef I_STDARG
  17 #  include <stdarg.h>
  18 #endif
  19 #define FLUSH
  20
  21 static char nomem[] = "Out of memory!\n";
  22
  23 /* paranoid version of malloc */
  24
  25
  26 Malloc_t
  27 safemalloc(MEM_SIZE size)
  28 {
  29     Malloc_t ptr;
  30
  31     /* malloc(0) is NASTY on some systems */
  32     ptr = malloc(size ? size : 1);
  33 #ifdef DEBUGGING
  34     if (debug & 128)
  35         fprintf(stderr,"0x%lx: (%05d) malloc %ld bytes\n",(unsigned long)ptr,
  36                 an++,(long)size);
  37 #endif
  38     if (ptr != Nullch)
  39         return ptr;
  40     else {
  41         fputs(nomem,stdout) FLUSH;
  42         exit(1);
  43     }
  44     /*NOTREACHED*/
  45     return 0;
  46 }
  47
  48 /* paranoid version of realloc */
  49
  50 Malloc_t
  51 saferealloc(Malloc_t where, MEM_SIZE size)
  52 {
  53     Malloc_t ptr;
  54
  55     /* realloc(0) is NASTY on some systems */
  56     ptr = realloc(where, size ? size : 1);
  57 #ifdef DEBUGGING
  58     if (debug & 128) {
  59         fprintf(stderr,"0x%lx: (%05d) rfree\n",(unsigned long)where,an++);
  60         fprintf(stderr,"0x%lx: (%05d) realloc %ld bytes\n",(unsigned long)ptr,an++,(long)size);
  61     }
  62 #endif
  63     if (ptr != Nullch)
  64         return ptr;
  65     else {
  66         fputs(nomem,stdout) FLUSH;
  67         exit(1);
  68     }
  69     /*NOTREACHED*/
  70     return 0;
  71 }
  72
  73 /* safe version of free */
  74
  75 Free_t
  76 safefree(Malloc_t where)
  77 {
  78 #ifdef DEBUGGING
  79     if (debug & 128)
  80         fprintf(stderr,"0x%lx: (%05d) free\n",(unsigned long)where,an++);
  81 #endif
  82     free(where);
  83 }
  84
  85 /* safe version of string copy */
  86
  87 char *
  88 safecpy(char *to, register char *from, register int len)
  89 {
  90     register char *dest = to;
  91
  92     if (from != Nullch)
  93         for (len--; len && (*dest++ = *from++); len--) ;
  94     *dest = '\0';
  95     return to;
  96 }
  97
  98 /* copy a string up to some (non-backslashed) delimiter, if any */
  99
 100 char *
 101 cpytill(register char *to, register char *from, register int delim)
 102 {
 103     for (; *from; from++,to++) {
 104         if (*from == '\\') {
 105             if (from[1] == delim)
 106                 from++;
 107             else if (from[1] == '\\')
 108                 *to++ = *from++;
 109         }
 110         else if (*from == delim)
 111             break;
 112         *to = *from;
 113     }
 114     *to = '\0';
 115     return from;
 116 }
 117
 118
 119 char *
 120 cpy2(register char *to, register char *from, register int delim)
 121 {
 122     for (; *from; from++,to++) {
 123         if (*from == '\\')
 124             *to++ = *from++;
 125         else if (*from == '$')
 126             *to++ = '\\';
 127         else if (*from == delim)
 128             break;
 129         *to = *from;
 130     }
 131     *to = '\0';
 132     return from;
 133 }
 134
 135 /* return ptr to little string in big string, NULL if not found */
 136
 137 char *
 138 instr(char *big, char *little)
 139 {
 140     register char *t, *s, *x;
 141
 142     for (t = big; *t; t++) {
 143         for (x=t,s=little; *s; x++,s++) {
 144             if (!*x)
 145                 return Nullch;
 146             if (*s != *x)
 147                 break;
 148         }
 149         if (!*s)
 150             return t;
 151     }
 152     return Nullch;
 153 }
 154
 155 /* copy a string to a safe spot */
 156
 157 char *
 158 savestr(char *str)
 159 {
 160     register char *newaddr = (char *) safemalloc((MEM_SIZE)(strlen(str)+1));
 161
 162     (void)strcpy(newaddr,str);
 163     return newaddr;
 164 }
 165
 166 /* grow a static string to at least a certain length */
 167
 168 void
 169 growstr(char **strptr, int *curlen, int newlen)
 170 {
 171     if (newlen > *curlen) {             /* need more room? */
 172         if (*curlen)
 173             *strptr = (char *) saferealloc(*strptr,(MEM_SIZE)newlen);
 174         else
 175             *strptr = (char *) safemalloc((MEM_SIZE)newlen);
 176         *curlen = newlen;
 177     }
 178 }
 179
 180 void
 181 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 182 croak(char *pat,...)
 183 #else /* I_STDARG */
 184 /*VARARGS1*/
 185 croak(pat,a1,a2,a3,a4)
 186     char *pat;
 187     int a1,a2,a3,a4;
 188 #endif /* I_STDARG */
 189 {
 190 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 191     va_list args;
 192
 193     va_start(args, pat);
 194     vfprintf(stderr,pat,args);
 195 #else
 196     fprintf(stderr,pat,a1,a2,a3,a4);
 197 #endif
 198     exit(1);
 199 }
 200
 201 void
 202 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 203 fatal(char *pat,...)
 204 #else /* I_STDARG */
 205 /*VARARGS1*/
 206 fatal(pat,a1,a2,a3,a4)
 207     char *pat;
 208     int a1,a2,a3,a4;
 209 #endif /* I_STDARG */
 210 {
 211 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 212     va_list args;
 213
 214     va_start(args, pat);
 215     vfprintf(stderr,pat,args);
 216 #else
 217     fprintf(stderr,pat,a1,a2,a3,a4);
 218 #endif
 219     exit(1);
 220 }
 221
 222 void
 223 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 224 warn(char *pat,...)
 225 #else /* I_STDARG */
 226 /*VARARGS1*/
 227 warn(pat,a1,a2,a3,a4)
 228     char *pat;
 229     int a1,a2,a3,a4;
 230 #endif /* I_STDARG */
 231 {
 232 #if defined(I_STDARG) && defined(HAS_VPRINTF)
 233     va_list args;
 234
 235     va_start(args, pat);
 236     vfprintf(stderr,pat,args);
 237 #else
 238     fprintf(stderr,pat,a1,a2,a3,a4);
 239 #endif
 240 }
 241