usr/src/cmd/csh/sh.misc.c

   1 /*
   2  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5
   6 /*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
   7 /*        All Rights Reserved   */
   8
   9 /*
  10  * Copyright (c) 1980 Regents of the University of California.
  11  * All rights reserved.  The Berkeley Software License Agreement
  12  * specifies the terms and conditions for redistribution.
  13  */
  14
  15 #pragma ident   "%Z%%M% %I%     %E% SMI"
  16
  17 #include "sh.h"
  18 #include "sh.tconst.h"
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21
  22 /*
  23  * C Shell
  24  */
  25 tchar   **blkcat(tchar **, tchar **);
  26 tchar   **blkend(tchar **);
  27
  28 int
  29 any(int c, tchar *s)
  30 {
  31
  32         while (s && *s)
  33                 if (*s++ == c)
  34                         return (1);
  35         return (0);
  36 }
  37
  38 int
  39 onlyread(tchar *cp)
  40 {
  41         extern char end[];
  42
  43         return ((char *)cp < end);
  44 }
  45
  46 tchar *
  47 savestr(tchar *s)
  48 {
  49         tchar *n;
  50         tchar *p;
  51
  52         if (s == 0)
  53                 s = S_ /* "" */;
  54 #ifndef m32
  55         for (p = s; *p++; )
  56                 ;
  57         n = p = (tchar *)xalloc((unsigned)(p - s)*sizeof (tchar));
  58         while (*p++ = *s++)
  59                 ;
  60         return (n);
  61 #else
  62         p = (tchar *) xalloc((strlen_(s) + 1)*sizeof (tchar));
  63         strcpy_(p, s);
  64         return (p);
  65 #endif
  66 }
  67
  68 static void *
  69 nomem(size_t i)
  70 {
  71 #ifdef debug
  72         static tchar *av[2] = {0, 0};
  73 #endif
  74
  75         child++;
  76 #ifndef debug
  77         error("Out of memory");
  78 #else
  79         showall(av);
  80         printf("i=%d: Out of memory\n", i);
  81         chdir("/usr/bill/cshcore");
  82         abort();
  83 #endif
  84         return (0);             /* fool lint */
  85 }
  86
  87 tchar **
  88 blkend(tchar **up)
  89 {
  90
  91         while (*up)
  92                 up++;
  93         return (up);
  94 }
  95
  96 void
  97 blkpr(tchar **av)
  98 {
  99
 100         for (; *av; av++) {
 101                 printf("%t", *av);
 102                 if (av[1])
 103                         printf(" ");
 104         }
 105 }
 106
 107 int
 108 blklen(tchar **av)
 109 {
 110         int i = 0;
 111
 112         while (*av++)
 113                 i++;
 114         return (i);
 115 }
 116
 117 tchar **
 118 blkcpy(tchar **oav, tchar **bv)
 119 {
 120         tchar **av = oav;
 121
 122         while (*av++ = *bv++)
 123                 continue;
 124         return (oav);
 125 }
 126
 127 tchar **
 128 blkcat(tchar **up, tchar **vp)
 129 {
 130
 131         (void) blkcpy(blkend(up), vp);
 132         return (up);
 133 }
 134
 135 void
 136 blkfree(tchar **av0)
 137 {
 138         tchar **av = av0;
 139
 140         for (; *av; av++)
 141                 xfree(*av);
 142         xfree(av0);
 143 }
 144
 145 tchar **
 146 saveblk(tchar **v)
 147 {
 148         tchar **newv =
 149                 (tchar **)xcalloc((unsigned)(blklen(v) + 1),
 150                                 sizeof (tchar **));
 151         tchar **onewv = newv;
 152
 153         while (*v)
 154                 *newv++ = savestr(*v++);
 155         return (onewv);
 156 }
 157
 158 tchar *
 159 strspl(tchar *cp, tchar *dp)
 160 {
 161         tchar *ep;
 162         tchar *p, *q;
 163
 164 #ifndef m32
 165         for (p = cp; *p++; )
 166                 ;
 167         for (q = dp; *q++; )
 168                 ;
 169         ep = (tchar *) xalloc((unsigned)(((p - cp) +
 170                         (q - dp) - 1))*sizeof (tchar));
 171         for (p = ep, q = cp; *p++ = *q++; )
 172                 ;
 173         for (p--, q = dp; *p++ = *q++; )
 174                 ;
 175 #else
 176         int     len1 = strlen_(cp);
 177         int     len2 = strlen_(dp);
 178
 179         ep = (tchar *)xalloc((unsigned)(len1 + len2 + 1)*sizeof (tchar));
 180         strcpy_(ep, cp);
 181         strcat_(ep, dp);
 182 #endif
 183         return (ep);
 184 }
 185
 186 tchar **
 187 blkspl(tchar **up, tchar **vp)
 188 {
 189         tchar **wp =
 190                 (tchar **)xcalloc((unsigned)(blklen(up) + blklen(vp) + 1),
 191                         sizeof (tchar **));
 192
 193         (void) blkcpy(wp, up);
 194         return (blkcat(wp, vp));
 195 }
 196
 197 int
 198 lastchr(tchar *cp)
 199 {
 200
 201         if (!*cp)
 202                 return (0);
 203         while (cp[1])
 204                 cp++;
 205         return (*cp);
 206 }
 207
 208 void
 209 donefds(void)
 210 {
 211         (void) close(0);
 212         (void) close(1);
 213         (void) close(2);
 214
 215         /*
 216          * To avoid NIS+ functions to get hold of 0/1/2,
 217          * use descriptor 0, and dup it to 1 and 2.
 218          */
 219         open("/dev/null", O_RDONLY);
 220         dup(0); dup(0);
 221         didfds = 0;
 222 }
 223
 224 /*
 225  * Move descriptor i to j.
 226  * If j is -1 then we just want to get i to a safe place,
 227  * i.e. to a unit > 2.  This also happens in dcopy.
 228  */
 229 int
 230 dmove(int i, int j)
 231 {
 232         int fd;
 233
 234         if (i == j || i < 0)
 235                 return (i);
 236         if (j >= 0) {
 237                 fd = dup2(i, j);
 238                 if (fd != -1)
 239                         setfd(fd);
 240         } else
 241                 j = dcopy(i, j);
 242         if (j != i) {
 243                 (void) close(i);
 244                 unsetfd(i);
 245         }
 246         return (j);
 247 }
 248
 249 int
 250 dcopy(int i, int j)
 251 {
 252
 253         int fd;
 254
 255         if (i == j || i < 0 || j < 0 && i > 2)
 256                 return (i);
 257         if (j >= 0) {
 258                 fd = dup2(i, j);
 259                 if (fd != -1)
 260                         setfd(fd);
 261                 return (j);
 262         }
 263         (void) close(j);
 264         unsetfd(j);
 265         return (renum(i, j));
 266 }
 267
 268 int
 269 renum(int i, int j)
 270 {
 271         int k = dup(i);
 272
 273         if (k < 0)
 274                 return (-1);
 275         if (j == -1 && k > 2) {
 276                 setfd(k);
 277                 return (k);
 278         }
 279         if (k != j) {
 280                 j = renum(k, j);
 281                 (void) close(k);        /* no need ofr unsetfd() */
 282                 return (j);
 283         }
 284         return (k);
 285 }
 286
 287 #ifndef copy
 288 void
 289 copy(tchar *to, tchar *from, int size)
 290 {
 291
 292         if (size)
 293                 do
 294                         *to++ = *from++;
 295                 while (--size != 0);
 296 }
 297 #endif
 298
 299 /*
 300  * Left shift a command argument list, discarding
 301  * the first c arguments.  Used in "shift" commands
 302  * as well as by commands like "repeat".
 303  */
 304 void
 305 lshift(tchar **v, int c)
 306 {
 307         tchar **u = v;
 308
 309         while (*u && --c >= 0)
 310                 xfree((char *)*u++);
 311         (void) blkcpy(v, u);
 312 }
 313
 314 int
 315 number(tchar *cp)
 316 {
 317
 318         if (*cp == '-') {
 319                 cp++;
 320                 if (!digit(*cp++))
 321                         return (0);
 322         }
 323         while (*cp && digit(*cp))
 324                 cp++;
 325         return (*cp == 0);
 326 }
 327
 328 tchar **
 329 copyblk(tchar **v)
 330 {
 331         tchar **nv =
 332                 (tchar **)xcalloc((unsigned)(blklen(v) + 1),
 333                                 sizeof (tchar **));
 334
 335         return (blkcpy(nv, v));
 336 }
 337
 338 tchar *
 339 strend(tchar *cp)
 340 {
 341
 342         while (*cp)
 343                 cp++;
 344         return (cp);
 345 }
 346
 347 tchar *
 348 strip(tchar *cp)
 349 {
 350         tchar *dp = cp;
 351
 352         while (*dp++ &= TRIM)
 353                 continue;
 354         return (cp);
 355 }
 356
 357 void
 358 udvar(tchar *name)
 359 {
 360
 361         setname(name);
 362         bferr("Undefined variable");
 363 }
 364
 365 int
 366 prefix(tchar *sub, tchar *str)
 367 {
 368
 369         for (;;) {
 370                 if (*sub == 0)
 371                         return (1);
 372                 if (*str == 0)
 373                         return (0);
 374                 if (*sub++ != *str++)
 375                         return (0);
 376         }
 377 }
 378
 379 /*
 380  * blk*_ routines
 381  */
 382
 383 char **
 384 blkend_(char **up)
 385 {
 386
 387         while (*up)
 388                 up++;
 389         return (up);
 390 }
 391
 392 int
 393 blklen_(char **av)
 394 {
 395         int i = 0;
 396
 397         while (*av++)
 398                 i++;
 399         return (i);
 400 }
 401
 402 char **
 403 blkcpy_(char **oav, char **bv)
 404 {
 405         char **av = oav;
 406
 407         while (*av++ = *bv++)
 408                 continue;
 409         return (oav);
 410 }
 411
 412 char **
 413 blkcat_(char **up, char **vp)
 414 {
 415
 416         (void) blkcpy_(blkend_(up), vp);
 417         return (up);
 418 }
 419
 420 char **
 421 blkspl_(char **up, char **vp)
 422 {
 423         char **wp =
 424                 (char **)xcalloc((unsigned)(blklen_(up) + blklen_(vp) + 1),
 425                         sizeof (char **));
 426
 427         (void) blkcpy_(wp, up);
 428         return (blkcat_(wp, vp));
 429 }
 430
 431 /*
 432  * If stack address was passed to free(), we have no good way to see if
 433  * they are really in the stack. Therefore, we record the bottom of heap,
 434  * and filter out the address not within heap's top(end) and bottom
 435  * (xalloc_bottom).
 436  */
 437 extern char     end[];
 438 static char     *xalloc_bottom;
 439
 440 void *
 441 xalloc(size_t size)
 442 {
 443         char    *rptr, *bp;
 444
 445         if ((rptr = malloc(size)) == NULL)
 446                 return (nomem(size));
 447         bp = rptr + size;
 448         if (bp > xalloc_bottom)
 449                 xalloc_bottom = bp;
 450         return (rptr);
 451 }
 452
 453 void *
 454 xrealloc(void *ptr, size_t size)
 455 {
 456         char    *rptr = ptr, *bp;
 457
 458         if (ptr == NULL)
 459                 return (xalloc(size));
 460         if (rptr < end) {
 461                 /* data area, but not in heap area. don't touch it */
 462 oob:
 463                 if (size == 0)
 464                         return (NULL);
 465                 rptr = xalloc(size);
 466                 /* copy max size */
 467                 (void) memcpy(rptr, ptr, size);
 468                 return (rptr);
 469         }
 470         if (rptr < xalloc_bottom) {
 471                 /* address in the heap */
 472 inb:
 473                 if (size == 0) {
 474                         free(ptr);
 475                         return (NULL);
 476                 }
 477                 if ((rptr = realloc(ptr, size)) == NULL)
 478                         return (nomem(size));
 479                 bp = rptr + size;
 480                 if (bp > xalloc_bottom)
 481                         xalloc_bottom = bp;
 482                 return (rptr);
 483         }
 484         /*
 485          * can be a memory block returned indirectly from
 486          * library functions. update bottom, and check it again.
 487          */
 488         xalloc_bottom = sbrk(0);
 489         if (rptr <= xalloc_bottom)
 490                 goto inb;
 491         else
 492                 goto oob;
 493         /*NOTREACHED*/
 494 }
 495
 496 void
 497 xfree(void *ptr)
 498 {
 499         char    *rptr = ptr;
 500
 501         if (rptr < end) {
 502                 return;
 503         }
 504         if (rptr < xalloc_bottom) {
 505                 free(ptr);
 506                 return;
 507         }
 508         xalloc_bottom = sbrk(0);
 509         if (rptr <= xalloc_bottom) {
 510                 free(ptr);
 511         }
 512 }
 513
 514 void *
 515 xcalloc(size_t i, size_t j)
 516 {
 517         char *cp;
 518
 519         i *= j;
 520         cp = xalloc(i);
 521         (void) memset(cp, '\0', i);
 522         return (cp);
 523 }