Return to sh.misc.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / csh

Annotation of 3BSD/cmd/csh/sh.misc.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.