1: /* $Header: util.c,v 1.0 87/12/18 13:07:34 root Exp $
   2:  *
   3:  * $Log:	util.c,v $
   4:  * Revision 1.0  87/12/18  13:07:34  root
   5:  * Initial revision
   6:  *
   7:  */
   8: 
   9: #include <stdio.h>
  10: 
  11: #include "handy.h"
  12: #include "EXTERN.h"
  13: #include "a2p.h"
  14: #include "INTERN.h"
  15: #include "util.h"
  16: 
  17: #define FLUSH
  18: #define MEM_SIZE unsigned int
  19: 
  20: static char nomem[] = "Out of memory!\n";
  21: 
  22: /* paranoid version of malloc */
  23: 
  24: static int an = 0;
  25: 
  26: char *
  27: safemalloc(size)
  28: MEM_SIZE size;
  29: {
  30:     char *ptr;
  31:     char *malloc();
  32: 
  33:     ptr = malloc(size?size:1);  /* malloc(0) is NASTY on our system */
  34: #ifdef DEBUGGING
  35:     if (debug & 128)
  36:     fprintf(stderr,"0x%x: (%05d) malloc %d bytes\n",ptr,an++,size);
  37: #endif
  38:     if (ptr != Nullch)
  39:     return ptr;
  40:     else {
  41:     fputs(nomem,stdout) FLUSH;
  42:     exit(1);
  43:     }
  44:     /*NOTREACHED*/
  45: }
  46: 
  47: /* paranoid version of realloc */
  48: 
  49: char *
  50: saferealloc(where,size)
  51: char *where;
  52: MEM_SIZE size;
  53: {
  54:     char *ptr;
  55:     char *realloc();
  56: 
  57:     ptr = realloc(where,size?size:1);   /* realloc(0) is NASTY on our system */
  58: #ifdef DEBUGGING
  59:     if (debug & 128) {
  60:     fprintf(stderr,"0x%x: (%05d) rfree\n",where,an++);
  61:     fprintf(stderr,"0x%x: (%05d) realloc %d bytes\n",ptr,an++,size);
  62:     }
  63: #endif
  64:     if (ptr != Nullch)
  65:     return ptr;
  66:     else {
  67:     fputs(nomem,stdout) FLUSH;
  68:     exit(1);
  69:     }
  70:     /*NOTREACHED*/
  71: }
  72: 
  73: /* safe version of free */
  74: 
  75: safefree(where)
  76: char *where;
  77: {
  78: #ifdef DEBUGGING
  79:     if (debug & 128)
  80:     fprintf(stderr,"0x%x: (%05d) free\n",where,an++);
  81: #endif
  82:     free(where);
  83: }
  84: 
  85: /* safe version of string copy */
  86: 
  87: char *
  88: safecpy(to,from,len)
  89: char *to;
  90: register char *from;
  91: register int len;
  92: {
  93:     register char *dest = to;
  94: 
  95:     if (from != Nullch)
  96:     for (len--; len && (*dest++ = *from++); len--) ;
  97:     *dest = '\0';
  98:     return to;
  99: }
 100: 
 101: #ifdef undef
 102: /* safe version of string concatenate, with \n deletion and space padding */
 103: 
 104: char *
 105: safecat(to,from,len)
 106: char *to;
 107: register char *from;
 108: register int len;
 109: {
 110:     register char *dest = to;
 111: 
 112:     len--;              /* leave room for null */
 113:     if (*dest) {
 114:     while (len && *dest++) len--;
 115:     if (len) {
 116:         len--;
 117:         *(dest-1) = ' ';
 118:     }
 119:     }
 120:     if (from != Nullch)
 121:     while (len && (*dest++ = *from++)) len--;
 122:     if (len)
 123:     dest--;
 124:     if (*(dest-1) == '\n')
 125:     dest--;
 126:     *dest = '\0';
 127:     return to;
 128: }
 129: #endif
 130: 
 131: /* copy a string up to some (non-backslashed) delimiter, if any */
 132: 
 133: char *
 134: cpytill(to,from,delim)
 135: register char *to, *from;
 136: register int delim;
 137: {
 138:     for (; *from; from++,to++) {
 139:     if (*from == '\\' && from[1] == delim)
 140:         *to++ = *from++;
 141:     else if (*from == delim)
 142:         break;
 143:     *to = *from;
 144:     }
 145:     *to = '\0';
 146:     return from;
 147: }
 148: 
 149: char *
 150: cpy2(to,from,delim)
 151: register char *to, *from;
 152: register int delim;
 153: {
 154:     for (; *from; from++,to++) {
 155:     if (*from == '\\' && from[1] == delim)
 156:         *to++ = *from++;
 157:     else if (*from == '$')
 158:         *to++ = '\\';
 159:     else if (*from == delim)
 160:         break;
 161:     *to = *from;
 162:     }
 163:     *to = '\0';
 164:     return from;
 165: }
 166: 
 167: /* return ptr to little string in big string, NULL if not found */
 168: 
 169: char *
 170: instr(big, little)
 171: char *big, *little;
 172: 
 173: {
 174:     register char *t, *s, *x;
 175: 
 176:     for (t = big; *t; t++) {
 177:     for (x=t,s=little; *s; x++,s++) {
 178:         if (!*x)
 179:         return Nullch;
 180:         if (*s != *x)
 181:         break;
 182:     }
 183:     if (!*s)
 184:         return t;
 185:     }
 186:     return Nullch;
 187: }
 188: 
 189: /* copy a string to a safe spot */
 190: 
 191: char *
 192: savestr(str)
 193: char *str;
 194: {
 195:     register char *newaddr = safemalloc((MEM_SIZE)(strlen(str)+1));
 196: 
 197:     (void)strcpy(newaddr,str);
 198:     return newaddr;
 199: }
 200: 
 201: /* grow a static string to at least a certain length */
 202: 
 203: void
 204: growstr(strptr,curlen,newlen)
 205: char **strptr;
 206: int *curlen;
 207: int newlen;
 208: {
 209:     if (newlen > *curlen) {     /* need more room? */
 210:     if (*curlen)
 211:         *strptr = saferealloc(*strptr,(MEM_SIZE)newlen);
 212:     else
 213:         *strptr = safemalloc((MEM_SIZE)newlen);
 214:     *curlen = newlen;
 215:     }
 216: }
 217: 
 218: /*VARARGS1*/
 219: fatal(pat,a1,a2,a3,a4)
 220: char *pat;
 221: {
 222:     fprintf(stderr,pat,a1,a2,a3,a4);
 223:     exit(1);
 224: }
 225: 
 226: static bool firstsetenv = TRUE;
 227: extern char **environ;
 228: 
 229: void
 230: setenv(nam,val)
 231: char *nam, *val;
 232: {
 233:     register int i=envix(nam);      /* where does it go? */
 234: 
 235:     if (!environ[i]) {          /* does not exist yet */
 236:     if (firstsetenv) {      /* need we copy environment? */
 237:         int j;
 238: #ifndef lint
 239:         char **tmpenv = (char**)    /* point our wand at memory */
 240:         safemalloc((i+2) * sizeof(char*));
 241: #else
 242:         char **tmpenv = Null(char **);
 243: #endif /* lint */
 244: 
 245:         firstsetenv = FALSE;
 246:         for (j=0; j<i; j++)     /* copy environment */
 247:         tmpenv[j] = environ[j];
 248:         environ = tmpenv;       /* tell exec where it is now */
 249:     }
 250: #ifndef lint
 251:     else
 252:         environ = (char**) saferealloc((char*) environ,
 253:         (i+2) * sizeof(char*));
 254:                     /* just expand it a bit */
 255: #endif /* lint */
 256:     environ[i+1] = Nullch;  /* make sure it's null terminated */
 257:     }
 258:     environ[i] = safemalloc(strlen(nam) + strlen(val) + 2);
 259:                     /* this may or may not be in */
 260:                     /* the old environ structure */
 261:     sprintf(environ[i],"%s=%s",nam,val);/* all that work just for this */
 262: }
 263: 
 264: int
 265: envix(nam)
 266: char *nam;
 267: {
 268:     register int i, len = strlen(nam);
 269: 
 270:     for (i = 0; environ[i]; i++) {
 271:     if (strnEQ(environ[i],nam,len) && environ[i][len] == '=')
 272:         break;          /* strnEQ must come first to avoid */
 273:     }                   /* potential SEGV's */
 274:     return i;
 275: }

Defined functions

envix defined in line 264; used 2 times
instr defined in line 169; used 1 times
safecat defined in line 104; used 1 times
safecpy defined in line 87; used 1 times
setenv defined in line 229; used 1 times

Defined variables

an defined in line 24; used 4 times
nomem defined in line 20; used 2 times

Defined macros

FLUSH defined in line 17; used 2 times
MEM_SIZE defined in line 18; used 5 times
Last modified: 1988-02-03
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1765
Valid CSS Valid XHTML 1.0 Strict