Return to func.c CVS log

Up to [Research Unix] / researchv8dc / cmd / sh

Annotation of researchv8dc/cmd/sh/func.c, revision 1.1

1.1     ! root        1: /*     @(#)func.c      1.2     */
        !             2: /*
        !             3:  * UNIX shell
        !             4:  *
        !             5:  * Bell Telephone Laboratories
        !             6:  *
        !             7:  */
        !             8: 
        !             9: #include       "defs.h"
        !            10: 
        !            11: static char    *strfp;
        !            12: 
        !            13: #define        prfc(c) (*strfp++ = (c))
        !            14: 
        !            15: freefunc(val)
        !            16:        char *val;
        !            17: {
        !            18:        freetree((struct trenod *)val);
        !            19: }
        !            20: 
        !            21: 
        !            22: freetree(t)
        !            23:        register struct trenod *t;
        !            24: {
        !            25:        if (t)
        !            26:        {
        !            27:                register int type;
        !            28: 
        !            29:                if (t->tretyp & CNTMSK)
        !            30:                {
        !            31:                        t->tretyp--;
        !            32:                        return;
        !            33:                }
        !            34: 
        !            35:                type = t->tretyp & COMMSK;
        !            36: 
        !            37:                switch (type)
        !            38:                {
        !            39:                        case TFND:
        !            40:                                free(fndptr(t)->fndnam);
        !            41:                                freetree(fndptr(t)->fndval);
        !            42:                                break;
        !            43: 
        !            44:                        case TCOM:
        !            45:                                freeio(comptr(t)->comio);
        !            46:                                free_arg(comptr(t)->comarg);
        !            47:                                free_arg(comptr(t)->comset);
        !            48:                                break;
        !            49: 
        !            50:                        case TFORK:
        !            51:                                freeio(forkptr(t)->forkio);
        !            52:                                freetree(forkptr(t)->forktre);
        !            53:                                break;
        !            54: 
        !            55:                        case TPAR:
        !            56:                                freetree(parptr(t)->partre);
        !            57:                                break;
        !            58: 
        !            59:                        case TFIL:
        !            60:                        case TLST:
        !            61:                        case TAND:
        !            62:                        case TORF:
        !            63:                                freetree(lstptr(t)->lstlef);
        !            64:                                freetree(lstptr(t)->lstrit);
        !            65:                                break;
        !            66: 
        !            67:                        case TFOR:
        !            68:                        {
        !            69:                                struct fornod *f = (struct fornod *)t;
        !            70: 
        !            71:                                free(f->fornam);
        !            72:                                freetree(f->fortre);
        !            73:                                if (f->forlst)
        !            74:                                {
        !            75:                                        freeio(f->forlst->comio);
        !            76:                                        free_arg(f->forlst->comarg);
        !            77:                                        free_arg(f->forlst->comset);
        !            78:                                        free(f->forlst);
        !            79:                                }
        !            80:                        }
        !            81:                        break;
        !            82: 
        !            83:                        case TWH:
        !            84:                        case TUN:
        !            85:                                freetree(whptr(t)->whtre);
        !            86:                                freetree(whptr(t)->dotre);
        !            87:                                break;
        !            88: 
        !            89:                        case TIF:
        !            90:                                freetree(ifptr(t)->iftre);
        !            91:                                freetree(ifptr(t)->thtre);
        !            92:                                freetree(ifptr(t)->eltre);
        !            93:                                break;
        !            94: 
        !            95:                        case TSW:
        !            96:                                free(swptr(t)->swarg);
        !            97:                                freereg(swptr(t)->swlst);
        !            98:                                break;
        !            99:                }
        !           100:                free(t);
        !           101:        }
        !           102: }
        !           103: 
        !           104: free_arg(argp)
        !           105:        register struct argnod  *argp;
        !           106: {
        !           107:        register struct argnod  *sav;
        !           108: 
        !           109:        while (argp)
        !           110:        {
        !           111:                sav = argp->argnxt;
        !           112:                free(argp);
        !           113:                argp = sav;
        !           114:        }
        !           115: }
        !           116: 
        !           117: 
        !           118: freeio(iop)
        !           119:        register struct ionod *iop;
        !           120: {
        !           121:        register struct ionod *sav;
        !           122: 
        !           123:        while (iop)
        !           124:        {
        !           125:                if ((iop->iofile & IODOC) && fiotemp != 0)
        !           126:                {
        !           127: 
        !           128: #ifdef DEBUG
        !           129:                        prs("unlinking ");
        !           130:                        prs(iop->ioname);
        !           131:                        newline();
        !           132: #endif
        !           133: 
        !           134:                        unlink(iop->ioname);
        !           135: 
        !           136:                        if (fiotemp == iop)
        !           137:                                fiotemp = iop->iolst;
        !           138:                        else
        !           139:                        {
        !           140:                                struct ionod *fiop = fiotemp;
        !           141: 
        !           142:                                while (fiop->iolst != iop)
        !           143:                                        fiop = fiop->iolst;
        !           144:        
        !           145:                                fiop->iolst = iop->iolst;
        !           146:                        }
        !           147:                }
        !           148:                free(iop->ioname);
        !           149:                free(iop->iolink);
        !           150:                sav = iop->ionxt;
        !           151:                free(iop);
        !           152:                iop = sav;
        !           153:        }
        !           154: }
        !           155: 
        !           156: 
        !           157: freereg(regp)
        !           158:        register struct regnod  *regp;
        !           159: {
        !           160:        register struct regnod  *sav;
        !           161: 
        !           162:        while (regp)
        !           163:        {
        !           164:                free_arg(regp->regptr);
        !           165:                freetree(regp->regcom);
        !           166:                sav = regp->regnxt;
        !           167:                free(regp);
        !           168:                regp = sav;
        !           169:        }
        !           170: }
        !           171: /*
        !           172:  * Leaves string on top of stack
        !           173:  */
        !           174: char *
        !           175: strf(n)
        !           176: register struct namnod *n;
        !           177: {
        !           178:        strfp = locstak();
        !           179:        prfstr(n->namid);
        !           180:        prfstr("(){\n");
        !           181:        prf(n->namval.val);
        !           182:        prfstr("\n}");
        !           183:        return curstak();
        !           184: }
        !           185: prfstr(s)
        !           186:        char *s;
        !           187: {
        !           188:        strfp = movstr(s, strfp);
        !           189: }
        !           190: prf(t)
        !           191:        register struct trenod  *t;
        !           192: {
        !           193:        sigchk();
        !           194: 
        !           195:        if (t)
        !           196:        {
        !           197:                register int    type;
        !           198: 
        !           199:                type = t->tretyp & COMMSK;
        !           200: 
        !           201:                switch(type)
        !           202:                {
        !           203:                        case TFND:
        !           204:                        {
        !           205:                                register struct fndnod *f = (struct fndnod *)t;
        !           206: 
        !           207:                                prfstr(f->fndnam);
        !           208:                                prfstr("(){\n");
        !           209:                                prf(f->fndval);
        !           210:                                prfstr("\n}");
        !           211:                                break;
        !           212:                        }
        !           213: 
        !           214:                        case TCOM:
        !           215:                        {
        !           216:                                prarg(comptr(t)->comset);
        !           217:                                prarg(comptr(t)->comarg);
        !           218:                                prio(comptr(t)->comio);
        !           219:                                break;
        !           220:                        }
        !           221: 
        !           222:                        case TFORK:
        !           223:                                prf(forkptr(t)->forktre);
        !           224:                                prio(forkptr(t)->forkio);
        !           225:                                if (forkptr(t)->forktyp & FAMP)
        !           226:                                        prfstr(" &");
        !           227:                                break;
        !           228: 
        !           229:                        case TPAR:
        !           230:                                prfstr("(");
        !           231:                                prf(parptr(t)->partre);
        !           232:                                prfstr(")");
        !           233:                                break;
        !           234: 
        !           235:                        case TFIL:
        !           236:                                prf(lstptr(t)->lstlef);
        !           237:                                prfstr(" | ");
        !           238:                                prf(lstptr(t)->lstrit);
        !           239:                                break;
        !           240: 
        !           241:                        case TLST:
        !           242:                                prf(lstptr(t)->lstlef);
        !           243:                                prfc(NL);
        !           244:                                prf(lstptr(t)->lstrit);
        !           245:                                break;
        !           246: 
        !           247:                        case TAND:
        !           248:                                prf(lstptr(t)->lstlef);
        !           249:                                prfstr(" && ");
        !           250:                                prf(lstptr(t)->lstrit);
        !           251:                                break;
        !           252: 
        !           253:                        case TORF:
        !           254:                                prf(lstptr(t)->lstlef);
        !           255:                                prfstr(" || ");
        !           256:                                prf(lstptr(t)->lstrit);
        !           257:                                break;
        !           258: 
        !           259:                        case TFOR:
        !           260:                                {
        !           261:                                        register struct argnod  *arg;
        !           262:                                        register struct fornod  *f = (struct fornod *)t;
        !           263: 
        !           264:                                        prfstr("for ");
        !           265:                                        prfstr(f->fornam);
        !           266: 
        !           267:                                        if (f->forlst)
        !           268:                                        {
        !           269:                                                arg = f->forlst->comarg;
        !           270:                                                prfstr(" in");
        !           271: 
        !           272:                                                while(arg != ENDARGS)
        !           273:                                                {
        !           274:                                                        prfc(SP);
        !           275:                                                        prfqstr(arg->argval);
        !           276:                                                        arg = arg->argnxt;
        !           277:                                                }
        !           278:                                        }
        !           279: 
        !           280:                                        prfstr("\ndo\n");
        !           281:                                        prf(f->fortre);
        !           282:                                        prfstr("\ndone");
        !           283:                                }
        !           284:                                break;
        !           285: 
        !           286:                        case TWH:
        !           287:                        case TUN:
        !           288:                                if (type == TWH)
        !           289:                                        prfstr("while ");
        !           290:                                else
        !           291:                                        prfstr("until ");
        !           292:                                prf(whptr(t)->whtre);
        !           293:                                prfstr("\ndo\n");
        !           294:                                prf(whptr(t)->dotre);
        !           295:                                prfstr("\ndone");
        !           296:                                break;
        !           297: 
        !           298:                        case TIF:
        !           299:                        {
        !           300:                                struct ifnod *f = (struct ifnod *)t;
        !           301: 
        !           302:                                prfstr("if ");
        !           303:                                prf(f->iftre);
        !           304:                                prfstr("\nthen\n");
        !           305:                                prf(f->thtre);
        !           306: 
        !           307:                                if (f->eltre)
        !           308:                                {
        !           309:                                        prfstr("\nelse\n");
        !           310:                                        prf(f->eltre);
        !           311:                                }
        !           312: 
        !           313:                                prfstr("\nfi");
        !           314:                                break;
        !           315:                        }
        !           316: 
        !           317:                        case TSW:
        !           318:                                {
        !           319:                                        register struct regnod  *swl;
        !           320: 
        !           321:                                        prfstr("case ");
        !           322:                                        prfqstr(swptr(t)->swarg);
        !           323:                                        prfstr(" in\n");
        !           324: 
        !           325:                                        swl = swptr(t)->swlst;
        !           326:                                        while(swl)
        !           327:                                        {
        !           328:                                                struct argnod   *arg = swl->regptr;
        !           329: 
        !           330:                                                if (arg)
        !           331:                                                {
        !           332:                                                        prfqstr(arg->argval);
        !           333:                                                        arg = arg->argnxt;
        !           334:                                                }
        !           335: 
        !           336:                                                while(arg)
        !           337:                                                {
        !           338:                                                        prfc('|');
        !           339:                                                        prfqstr(arg->argval);
        !           340:                                                        arg = arg->argnxt;
        !           341:                                                }
        !           342: 
        !           343:                                                prfstr(") ");
        !           344:                                                prf(swl->regcom);
        !           345:                                                prfstr(";;\n");
        !           346:                                                swl = swl->regnxt;
        !           347:                                        }
        !           348:                                        prfstr("esac");
        !           349:                                }
        !           350:                                break;
        !           351:                        } 
        !           352:                } 
        !           353: 
        !           354:        sigchk();
        !           355: }
        !           356: 
        !           357: prarg(argp)
        !           358:        register struct argnod  *argp;
        !           359: {
        !           360:        while (argp)
        !           361:        {
        !           362:                prfqstr(argp->argval);
        !           363:                prfc(SP);
        !           364:                argp=argp->argnxt;
        !           365:        }
        !           366: }
        !           367: 
        !           368: prio(iop)
        !           369:        register struct ionod   *iop;
        !           370: {
        !           371:        register int    iof;
        !           372:        register char   *ion;
        !           373: 
        !           374:        while (iop)
        !           375:        {
        !           376:                iof = iop->iofile;
        !           377:                ion = iop->ioname;
        !           378: 
        !           379:                if (*ion)
        !           380:                {
        !           381:                        itos(iof & IOUFD);
        !           382:                        prfstr(numbuf);
        !           383: 
        !           384:                        if (iof & IODOC)
        !           385:                                prfstr("<<");
        !           386:                        else if (iof & IOMOV)
        !           387:                        {
        !           388:                                if (iof & IOPUT)
        !           389:                                        prfstr(">&");
        !           390:                                else
        !           391:                                        prfstr("<&");
        !           392: 
        !           393:                        }
        !           394:                        else if ((iof & IOPUT) == 0)
        !           395:                                prfc('<');
        !           396:                        else if (iof & IOAPP)
        !           397:                                prfstr(">>");
        !           398:                        else
        !           399:                                prfc('>');
        !           400: 
        !           401:                        prfstr(ion);
        !           402:                        prfc(SP);
        !           403:                }
        !           404:                iop = iop->ionxt;
        !           405:        }
        !           406: }
        !           407: prfqstr(p)
        !           408:        register char *p;
        !           409: {
        !           410:        int quote, equote;
        !           411:        int allquotes;
        !           412:     more:
        !           413:        quote = equote = allquotes = 0;
        !           414:        if(*p == '"'){
        !           415:                register char *t = p;
        !           416:                quote = equote = '"';
        !           417:                allquotes = 1;
        !           418:                while(*++t!='"')
        !           419:                        if(!(*t&QUOTE)){
        !           420:                                allquotes=0;
        !           421:                                break;
        !           422:                        }
        !           423:                if(allquotes)
        !           424:                        quote='\'';
        !           425:                prfc(quote);
        !           426:                p++;
        !           427:        }
        !           428:        while(*p != equote){
        !           429:                if(*p=='"')
        !           430:                        goto more;
        !           431:                if(!allquotes && (*p&QUOTE))
        !           432:                        prfc('\\');
        !           433:                prfc(*p++&~QUOTE);
        !           434:        }
        !           435:        if(quote){
        !           436:                prfc(quote);
        !           437:                if(*++p != 0)
        !           438:                        goto more;
        !           439:        }
        !           440: }
        !           441: 

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