home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Distributions / ucb / spencer_2bsd.tar.gz / 2bsd.tar / src / csh / sh.misc.c < prev    next >
C/C++ Source or Header  |  1980-02-17  |  4KB  |  327 lines
  1. /* Copyright (c) 1979 Regents of the University of California */
  2. #include "sh.h"
  3.  
  4. /*
  5.  * C Shell
  6.  */
  7.  
  8. letter(c)
  9.     register char c;
  10. {
  11.  
  12.     return (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '_');
  13. }
  14.  
  15. digit(c)
  16.     register char c;
  17. {
  18.  
  19.     return (c >= '0' && c <= '9');
  20. }
  21.  
  22. any(c, s)
  23.     register int c;
  24.     register char *s;
  25. {
  26.  
  27.     while (*s)
  28.         if (*s++ == c)
  29.             return(1);
  30.     return(0);
  31. }
  32.  
  33. char *
  34. calloc(i, j)
  35.     register int i;
  36.     int j;
  37. {
  38.     register char *cp, *dp;
  39.  
  40.     i *= j;
  41.     cp = (char *) malloc(i);
  42.     if (cp == 0) {
  43.         child++;
  44.         error("Out of memory");
  45.     }
  46.     dp = cp;
  47.     if (i > 0)
  48.         do
  49.             *dp++ = 0;
  50.         while (--i);
  51.     return (cp);
  52. }
  53.  
  54. cfree(p)
  55.     char *p;
  56. {
  57.  
  58.     free(p);
  59. }
  60.  
  61. char **
  62. blkend(up)
  63.     register char **up;
  64. {
  65.  
  66.     while (*up)
  67.         up++;
  68.     return (up);
  69. }
  70.  
  71. blkpr(av)
  72.     register int *av;
  73. {
  74.  
  75.     for (; *av; av++) {
  76.         printf("%s", *av);
  77.         if (av[1])
  78.             printf(" ");
  79.     }
  80. }
  81.  
  82. blklen(av)
  83.     register char **av;
  84. {
  85.     register int i = 0;
  86.  
  87.     while (*av++)
  88.         i++;
  89.     return (i);
  90. }
  91.  
  92. char **
  93. blkcpy(oav, bv)
  94.     char **oav;
  95.     register char **bv;
  96. {
  97.     register char **av = oav;
  98.  
  99.     while (*av++ = *bv++)
  100.         continue;
  101.     return (oav);
  102. }
  103.  
  104. char **
  105. blkcat(up, vp)
  106.     char **up, **vp;
  107. {
  108.  
  109.     blkcpy(blkend(up), vp);
  110.     return (up);
  111. }
  112.  
  113. blkfree(av0)
  114.     char **av0;
  115. {
  116.     register char **av = av0;
  117.  
  118.     while (*av)
  119.         xfree(*av++);
  120.     xfree(av0);
  121. }
  122.  
  123. char **
  124. saveblk(v)
  125.     register char **v;
  126. {
  127.     register int len = blklen(v) + 1;
  128.     register char **newv = (char **) calloc(len, sizeof (char **));
  129.     char **onewv = newv;
  130.  
  131.     while (*v)
  132.         *newv++ = savestr(*v++);
  133.     return (onewv);
  134. }
  135.  
  136. char *
  137. strspl(cp, dp)
  138.     register char *cp, *dp;
  139. {
  140.     register char *ep = calloc(1, strlen(cp) + strlen(dp) + 1);
  141.  
  142.     strcpy(ep, cp);
  143.     return (strcat(ep, dp));
  144. }
  145.  
  146. char **
  147. blkspl(up, vp)
  148.     register char **up, **vp;
  149. {
  150.     register char **wp = (char **) calloc(blklen(up) + blklen(vp) + 1, sizeof (char **));
  151.  
  152.     blkcpy(wp, up);
  153.     return (blkcat(wp, vp));
  154. }
  155.  
  156. lastchr(cp)
  157.     register char *cp;
  158. {
  159.  
  160.     if (!*cp)
  161.         return (0);
  162.     while (cp[1])
  163.         cp++;
  164.     return (*cp);
  165. }
  166.  
  167. /*
  168.  * This routine is called after an error to close up
  169.  * any units which may have been left open accidentally.
  170.  */
  171. closem()
  172. {
  173.     register int f;
  174.  
  175.     for (f = 0; f < NOFILE; f++)
  176.         if (f != SHIN && f != SHOUT && f != SHDIAG && f != OLDSTD)
  177.             close(f);
  178. }
  179.  
  180. /*
  181.  * Close files before executing a file.
  182.  * We could be MUCH more intelligent, since (on a version 7 system)
  183.  * we need only close files here during a source, the other
  184.  * shell fd's being in units 16-19 which are closed automatically!
  185.  */
  186. closech()
  187. {
  188.     register int f;
  189.  
  190.     if (didcch)
  191.         return;
  192.     didcch = 1;
  193.     SHIN = 0; SHOUT = 1; SHDIAG = 2; OLDSTD = 0;
  194.     for (f = 3; f < NOFILE; f++)
  195.         close(f);
  196. }
  197.  
  198. donefds()
  199. {
  200.  
  201.     close(0), close(1), close(2);
  202.     didfds = 0;
  203. }
  204.  
  205. /*
  206.  * Move descriptor i to j.
  207.  * If j is -1 then we just want to get i to a safe place,
  208.  * i.e. to a unit > 2.  This also happens in dcopy.
  209.  */
  210. dmove(i, j)
  211.     register int i, j;
  212. {
  213.  
  214.     if (i == j || i < 0)
  215.         return (i);
  216.     j = dcopy(i, j);
  217.     if (j != i)
  218.         close(i);
  219.     return (j);
  220. }
  221.  
  222. dcopy(i, j)
  223.     register int i, j;
  224. {
  225.  
  226.     if (i == j || i < 0 || j < 0 && i > 2)
  227.         return (i);
  228.     close(j);
  229.     return (renum(i, j));
  230. }
  231.  
  232. renum(i, j)
  233.     register int i, j;
  234. {
  235.     register int k = dup(i);
  236.  
  237.     if (k < 0)
  238.         return (-1);
  239.     if (j == -1 && k > 2)
  240.         return (k);
  241.     if (k != j) {
  242.         j = renum(k, j);
  243.         close(k);
  244.         return (j);
  245.     }
  246.     return (k);
  247. }
  248.  
  249. copy(to, from, size)
  250.     register char *to, *from;
  251.     register int size;
  252. {
  253.  
  254.     if (size)
  255.         do
  256.             *to++ = *from++;
  257.         while (--size != 0);
  258. }
  259.  
  260. /*
  261.  * Left shift a command argument list, discarding
  262.  * the first c arguments.  Used in "shift" commands
  263.  * as well as by commands like "repeat".
  264.  */
  265. lshift(v, c)
  266.     register char **v;
  267.     register int c;
  268. {
  269.     register char **u = v;
  270.  
  271.     while (*u && --c >= 0)
  272.         xfree(*u++);
  273.     blkcpy(v, u);
  274. }
  275.  
  276. number(cp)
  277.     char *cp;
  278. {
  279.  
  280.     if (*cp == '-') {
  281.         cp++;
  282.         if (!digit(*cp++))
  283.             return (0);
  284.     }
  285.     while (*cp && digit(*cp))
  286.         cp++;
  287.     return (*cp == 0);
  288. }
  289.  
  290. char **
  291. copyblk(v)
  292.     register char **v;
  293. {
  294.     register char **nv = (char **) calloc(blklen(v) + 1, sizeof (char **));
  295.  
  296.     return (blkcpy(nv, v));
  297. }
  298.  
  299. char *
  300. strend(cp)
  301.     register char *cp;
  302. {
  303.  
  304.     while (*cp)
  305.         cp++;
  306.     return (cp);
  307. }
  308.  
  309. char *
  310. strip(cp)
  311.     char *cp;
  312. {
  313.     register char *dp = cp;
  314.  
  315.     while (*dp++ &= TRIM)
  316.         continue;
  317.     return (cp);
  318. }
  319.  
  320. udvar(name)
  321.     char *name;
  322. {
  323.  
  324.     setname(name);
  325.     bferr("Undefined variable");
  326. }
  327.