Return to name.c CVS log

Up to [CSRG BSD Unix] / 42BSD / bin / sh

Annotation of 42BSD/bin/sh/name.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)name.c     4.2 8/11/83";
        !             3: #endif
        !             4: 
        !             5: #
        !             6: /*
        !             7:  * UNIX shell
        !             8:  *
        !             9:  * S. R. Bourne
        !            10:  * Bell Telephone Laboratories
        !            11:  *
        !            12:  */
        !            13: 
        !            14: #include       "defs.h"
        !            15: 
        !            16: PROC BOOL      chkid();
        !            17: 
        !            18: 
        !            19: NAMNOD ps2nod  = {     NIL,            NIL,            ps2name},
        !            20:        fngnod  = {     NIL,            NIL,            fngname},
        !            21:        pathnod = {     NIL,            NIL,            pathname},
        !            22:        ifsnod  = {     NIL,            NIL,            ifsname},
        !            23:        ps1nod  = {     &pathnod,       &ps2nod,        ps1name},
        !            24:        homenod = {     &fngnod,        &ifsnod,        homename},
        !            25:        mailnod = {     &homenod,       &ps1nod,        mailname};
        !            26: 
        !            27: NAMPTR         namep = &mailnod;
        !            28: 
        !            29: 
        !            30: /* ========    variable and string handling    ======== */
        !            31: 
        !            32: syslook(w,syswds)
        !            33:        STRING          w;
        !            34:        SYSTAB          syswds;
        !            35: {
        !            36:        REG CHAR        first;
        !            37:        REG STRING      s;
        !            38:        REG SYSPTR      syscan;
        !            39: 
        !            40:        syscan=syswds; first = *w;
        !            41: 
        !            42:        WHILE s=syscan->sysnam
        !            43:        DO  IF first == *s
        !            44:                ANDF eq(w,s)
        !            45:            THEN return(syscan->sysval);
        !            46:            FI
        !            47:            syscan++;
        !            48:        OD
        !            49:        return(0);
        !            50: }
        !            51: 
        !            52: setlist(arg,xp)
        !            53:        REG ARGPTR      arg;
        !            54:        INT             xp;
        !            55: {
        !            56:        WHILE arg
        !            57:        DO REG STRING   s=mactrim(arg->argval);
        !            58:           setname(s, xp);
        !            59:           arg=arg->argnxt;
        !            60:           IF flags&execpr
        !            61:           THEN prs(s);
        !            62:                IF arg THEN blank(); ELSE newline(); FI
        !            63:           FI
        !            64:        OD
        !            65: }
        !            66: 
        !            67: VOID   setname(argi, xp)
        !            68:        STRING          argi;
        !            69:        INT             xp;
        !            70: {
        !            71:        REG STRING      argscan=argi;
        !            72:        REG NAMPTR      n;
        !            73: 
        !            74:        IF letter(*argscan)
        !            75:        THEN    WHILE alphanum(*argscan) DO argscan++ OD
        !            76:                IF *argscan=='='
        !            77:                THEN    *argscan = 0;
        !            78:                        n=lookup(argi);
        !            79:                        *argscan++ = '=';
        !            80:                        attrib(n, xp);
        !            81:                        IF xp&N_ENVNAM
        !            82:                        THEN    n->namenv = n->namval = argscan;
        !            83:                        ELSE    assign(n, argscan);
        !            84:                        FI
        !            85:                        return;
        !            86:                FI
        !            87:        FI
        !            88:        failed(argi,notid);
        !            89: }
        !            90: 
        !            91: replace(a, v)
        !            92:        REG STRING      *a;
        !            93:        STRING          v;
        !            94: {
        !            95:        free(*a); *a=make(v);
        !            96: }
        !            97: 
        !            98: dfault(n,v)
        !            99:        NAMPTR          n;
        !           100:        STRING          v;
        !           101: {
        !           102:        IF n->namval==0
        !           103:        THEN    assign(n,v)
        !           104:        FI
        !           105: }
        !           106: 
        !           107: assign(n,v)
        !           108:        NAMPTR          n;
        !           109:        STRING          v;
        !           110: {
        !           111:        IF n->namflg&N_RDONLY
        !           112:        THEN    failed(n->namid,wtfailed);
        !           113:        ELSE    replace(&n->namval,v);
        !           114:        FI
        !           115: }
        !           116: 
        !           117: INT    readvar(names)
        !           118:        STRING          *names;
        !           119: {
        !           120:        FILEBLK         fb;
        !           121:        REG FILE        f = &fb;
        !           122:        REG CHAR        c;
        !           123:        REG INT         rc=0;
        !           124:        NAMPTR          n=lookup(*names++); /* done now to avoid storage mess */
        !           125:        STKPTR          rel=relstak();
        !           126: 
        !           127:        push(f); initf(dup(0));
        !           128:        IF lseek(0,0L,1)==-1
        !           129:        THEN    f->fsiz=1;
        !           130:        FI
        !           131: 
        !           132:        LOOP    c=nextc(0);
        !           133:                IF (*names ANDF any(c, ifsnod.namval)) ORF eolchar(c)
        !           134:                THEN    zerostak();
        !           135:                        assign(n,absstak(rel)); setstak(rel);
        !           136:                        IF *names
        !           137:                        THEN    n=lookup(*names++);
        !           138:                        ELSE    n=0;
        !           139:                        FI
        !           140:                        IF eolchar(c)
        !           141:                        THEN    break;
        !           142:                        FI
        !           143:                ELSE    pushstak(c);
        !           144:                FI
        !           145:        POOL
        !           146:        WHILE n
        !           147:        DO assign(n, nullstr);
        !           148:           IF *names THEN n=lookup(*names++); ELSE n=0; FI
        !           149:        OD
        !           150: 
        !           151:        IF eof THEN rc=1 FI
        !           152:        lseek(0, (long)(f->fnxt-f->fend), 1);
        !           153:        pop();
        !           154:        return(rc);
        !           155: }
        !           156: 
        !           157: assnum(p, i)
        !           158:        STRING          *p;
        !           159:        INT             i;
        !           160: {
        !           161:        itos(i); replace(p,numbuf);
        !           162: }
        !           163: 
        !           164: STRING make(v)
        !           165:        STRING          v;
        !           166: {
        !           167:        REG STRING      p;
        !           168: 
        !           169:        IF v
        !           170:        THEN    movstr(v,p=alloc(length(v)));
        !           171:                return(p);
        !           172:        ELSE    return(0);
        !           173:        FI
        !           174: }
        !           175: 
        !           176: 
        !           177: NAMPTR         lookup(nam)
        !           178:        REG STRING      nam;
        !           179: {
        !           180:        REG NAMPTR      nscan=namep;
        !           181:        REG NAMPTR      *prev;
        !           182:        INT             LR;
        !           183: 
        !           184:        IF !chkid(nam)
        !           185:        THEN    failed(nam,notid);
        !           186:        FI
        !           187:        WHILE nscan
        !           188:        DO      IF (LR=cf(nam,nscan->namid))==0
        !           189:                THEN    return(nscan);
        !           190:                ELIF LR<0
        !           191:                THEN    prev = &(nscan->namlft);
        !           192:                ELSE    prev = &(nscan->namrgt);
        !           193:                FI
        !           194:                nscan = *prev;
        !           195:        OD
        !           196: 
        !           197:        /* add name node */
        !           198:        nscan=alloc(sizeof *nscan);
        !           199:        nscan->namlft=nscan->namrgt=NIL;
        !           200:        nscan->namid=make(nam);
        !           201:        nscan->namval=0; nscan->namflg=N_DEFAULT; nscan->namenv=0;
        !           202:        return(*prev = nscan);
        !           203: }
        !           204: 
        !           205: LOCAL BOOL     chkid(nam)
        !           206:        STRING          nam;
        !           207: {
        !           208:        REG CHAR *      cp=nam;
        !           209: 
        !           210:        IF !letter(*cp)
        !           211:        THEN    return(FALSE);
        !           212:        ELSE    WHILE *++cp
        !           213:                DO IF !alphanum(*cp)
        !           214:                   THEN return(FALSE);
        !           215:                   FI
        !           216:                OD
        !           217:        FI
        !           218:        return(TRUE);
        !           219: }
        !           220: 
        !           221: LOCAL VOID (*namfn)();
        !           222: namscan(fn)
        !           223:        VOID            (*fn)();
        !           224: {
        !           225:        namfn=fn;
        !           226:        namwalk(namep);
        !           227: }
        !           228: 
        !           229: LOCAL VOID     namwalk(np)
        !           230:        REG NAMPTR      np;
        !           231: {
        !           232:        IF np
        !           233:        THEN    namwalk(np->namlft);
        !           234:                (*namfn)(np);
        !           235:                namwalk(np->namrgt);
        !           236:        FI
        !           237: }
        !           238: 
        !           239: VOID   printnam(n)
        !           240:        NAMPTR          n;
        !           241: {
        !           242:        REG STRING      s;
        !           243: 
        !           244:        sigchk();
        !           245:        IF s=n->namval
        !           246:        THEN    prs(n->namid);
        !           247:                prc('='); prs(s);
        !           248:                newline();
        !           249:        FI
        !           250: }
        !           251: 
        !           252: LOCAL STRING   staknam(n)
        !           253:        REG NAMPTR      n;
        !           254: {
        !           255:        REG STRING      p;
        !           256: 
        !           257:        p=movstr(n->namid,staktop);
        !           258:        p=movstr("=",p);
        !           259:        p=movstr(n->namval,p);
        !           260:        return(getstak(p+1-ADR(stakbot)));
        !           261: }
        !           262: 
        !           263: VOID   exname(n)
        !           264:        REG NAMPTR      n;
        !           265: {
        !           266:        IF n->namflg&N_EXPORT
        !           267:        THEN    free(n->namenv);
        !           268:                n->namenv = make(n->namval);
        !           269:        ELSE    free(n->namval);
        !           270:                n->namval = make(n->namenv);
        !           271:        FI
        !           272: }
        !           273: 
        !           274: VOID   printflg(n)
        !           275:        REG NAMPTR              n;
        !           276: {
        !           277:        IF n->namflg&N_EXPORT
        !           278:        THEN    prs(export); blank();
        !           279:        FI
        !           280:        IF n->namflg&N_RDONLY
        !           281:        THEN    prs(readonly); blank();
        !           282:        FI
        !           283:        IF n->namflg&(N_EXPORT|N_RDONLY)
        !           284:        THEN    prs(n->namid); newline();
        !           285:        FI
        !           286: }
        !           287: 
        !           288: VOID   getenv()
        !           289: {
        !           290:        REG STRING      *e=environ;
        !           291: 
        !           292:        WHILE *e
        !           293:        DO setname(*e++, N_ENVNAM) OD
        !           294: }
        !           295: 
        !           296: LOCAL INT      namec;
        !           297: 
        !           298: VOID   countnam(n)
        !           299:        NAMPTR          n;
        !           300: {
        !           301:        namec++;
        !           302: }
        !           303: 
        !           304: LOCAL STRING   *argnam;
        !           305: 
        !           306: VOID   pushnam(n)
        !           307:        NAMPTR          n;
        !           308: {
        !           309:        IF n->namval
        !           310:        THEN    *argnam++ = staknam(n);
        !           311:        FI
        !           312: }
        !           313: 
        !           314: STRING *setenv()
        !           315: {
        !           316:        REG STRING      *er;
        !           317: 
        !           318:        namec=0;
        !           319:        namscan(countnam);
        !           320:        argnam = er = getstak(namec*BYTESPERWORD+BYTESPERWORD);
        !           321:        namscan(pushnam);
        !           322:        *argnam++ = 0;
        !           323:        return(er);
        !           324: }

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