Ignore:
Timestamp:
Oct 6, 2007, 11:19:19 PM (18 years ago)
Author:
bird
Message:

moving globals into shinstance...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/expand.c

    r809 r1198  
    124124expandhere(union node *arg, int fd)
    125125{
    126         herefd = fd;
     126        psh->herefd = fd;
    127127        expandarg(arg, (struct arglist *)NULL, 0);
    128         xwrite(fd, stackblock(), expdest - stackblock());
     128        xwrite(psh, fd, stackblock(psh), expdest - stackblock(psh));
    129129}
    130130
    … …  
    144144
    145145        argbackq = arg->narg.backquote;
    146         STARTSTACKSTR(expdest);
     146        STARTSTACKSTR(psh, expdest);
    147147        ifsfirst.next = NULL;
    148148        ifslastp = NULL;
    … …  
    151151                return;                 /* here document expanded */
    152152        }
    153         STPUTC('\0', expdest);
    154         p = grabstackstr(expdest);
     153        STPUTC(psh, '\0', expdest);
     154        p = grabstackstr(psh, expdest);
    155155        exparg.lastp = &exparg.list;
    156156        /*
    … …  
    165165                if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
    166166                        rmescapes(p);
    167                 sp = (struct strlist *)stalloc(sizeof (struct strlist));
     167                sp = (struct strlist *)stalloc(psh, sizeof (struct strlist));
    168168                sp->text = p;
    169169                *exparg.lastp = sp;
    … …  
    210210                                break;
    211211                        if ((flag & EXP_FULL) != 0)
    212                                 STPUTC(c, expdest);
     212                                STPUTC(psh, c, expdest);
    213213                        ifs_split = 0;
    214214                        break;
    … …  
    218218                case CTLESC:
    219219                        if (quotes)
    220                                 STPUTC(c, expdest);
     220                                STPUTC(psh, c, expdest);
    221221                        c = *p++;
    222                         STPUTC(c, expdest);
     222                        STPUTC(psh, c, expdest);
    223223                        break;
    224224                case CTLVAR:
    … …  
    239239                         * assignments (after the first '=' and after ':'s).
    240240                         */
    241                         STPUTC(c, expdest);
     241                        STPUTC(psh, c, expdest);
    242242                        if (flag & EXP_VARTILDE && *p == '~') {
    243243                                if (c == '=') {
    … …  
    251251                        break;
    252252                default:
    253                         STPUTC(c, expdest);
     253                        STPUTC(psh, c, expdest);
    254254                        if (flag & EXP_IFS_SPLIT & ifs_split && strchr(ifs, c) != NULL) {
    255255                                /* We need to get the output split here... */
    256                                 recordregion(expdest - stackblock() - 1,
    257                                                 expdest - stackblock(), 0);
     256                                recordregion(expdest - stackblock(psh) - 1,
     257                                                expdest - stackblock(psh), 0);
    258258                        }
    259259                        break;
    … …  
    300300        while ((c = *home++) != '\0') {
    301301                if (quotes && SQSYNTAX[(int)c] == CCTL)
    302                         STPUTC(CTLESC, expdest);
    303                 STPUTC(c, expdest);
     302                        STPUTC(psh, CTLESC, expdest);
     303                STPUTC(psh, c, expdest);
    304304        }
    305305        return (p);
    … …  
    378378#error "integers with more than 10 digits are not supported"
    379379#endif
    380         CHECKSTRSPACE(12 - 2, expdest);
    381         USTPUTC('\0', expdest);
    382         start = stackblock();
     380        CHECKSTRSPACE(psh, 12 - 2, expdest);
     381        USTPUTC(psh, '\0', expdest);
     382        start = stackblock(psh);
    383383        p = expdest - 1;
    384384        while (*p != CTLARI && p >= start)
    … …  
    408408                recordregion(begoff, p - 1 - start, 0);
    409409        result = expdest - p + 1;
    410         STADJUST(-result, expdest);
     410        STADJUST(psh, -result, expdest);
    411411}
    412412
    … …  
    427427        struct nodelist *saveargbackq;
    428428        char lastc;
    429         int startloc = dest - stackblock();
     429        int startloc = dest - stackblock(psh);
    430430        char const *syntax = quoted? DQSYNTAX : BASESYNTAX;
    431431        int saveherefd;
    … …  
    436436        savelastp = ifslastp;
    437437        saveargbackq = argbackq;
    438         saveherefd = herefd;
    439         herefd = -1;
    440         p = grabstackstr(dest);
     438        saveherefd = psh->herefd;
     439        psh->herefd = -1;
     440        p = grabstackstr(psh, dest);
    441441        evalbackcmd(cmd, &in);
    442         ungrabstackstr(p, dest);
     442        ungrabstackstr(psh, p, dest);
    443443        ifsfirst = saveifs;
    444444        ifslastp = savelastp;
    445445        argbackq = saveargbackq;
    446         herefd = saveherefd;
     446        psh->herefd = saveherefd;
    447447
    448448        p = in.buf;
    … …  
    462462                if (lastc != '\0') {
    463463                        if (quotes && syntax[(int)lastc] == CCTL)
    464                                 STPUTC(CTLESC, dest);
    465                         STPUTC(lastc, dest);
     464                                STPUTC(psh, CTLESC, dest);
     465                        STPUTC(psh, lastc, dest);
    466466                }
    467467        }
    468468
    469469        /* Eat all trailing newlines */
    470         p = stackblock() + startloc;
     470        p = stackblock(psh) + startloc;
    471471        while (dest > p && dest[-1] == '\n')
    472                 STUNPUTC(dest);
     472                STUNPUTC(psh, dest);
    473473
    474474        if (in.fd >= 0)
    … …  
    479479                back_exitstatus = waitforjob(in.jp);
    480480        if (quoted == 0)
    481                 recordregion(startloc, dest - stackblock(), 0);
     481                recordregion(startloc, dest - stackblock(psh), 0);
    482482        TRACE(("evalbackq: size=%d: \"%.*s\"\n",
    483                 (dest - stackblock()) - startloc,
    484                 (dest - stackblock()) - startloc,
    485                 stackblock() + startloc));
     483                (dest - stackblock(psh)) - startloc,
     484                (dest - stackblock(psh)) - startloc,
     485                stackblock(psh) + startloc));
    486486        expdest = dest;
    487487        INTON;
    … …  
    497497        char *q;
    498498        int c = 0;
    499         int saveherefd = herefd;
     499        int saveherefd = psh->herefd;
    500500        struct nodelist *saveargbackq = argbackq;
    501501        int amount;
    502502
    503         herefd = -1;
     503        psh->herefd = -1;
    504504        argstr(p, 0);
    505         STACKSTRNUL(expdest);
    506         herefd = saveherefd;
     505        STACKSTRNUL(psh, expdest);
     506        psh->herefd = saveherefd;
    507507        argbackq = saveargbackq;
    508         startp = stackblock() + startloc;
     508        startp = stackblock(psh) + startloc;
    509509        if (str == NULL)
    510             str = stackblock() + strloc;
     510            str = stackblock(psh) + strloc;
    511511
    512512        switch (subtype) {
    … …  
    514514                setvar(str, startp, 0);
    515515                amount = startp - expdest;
    516                 STADJUST(amount, expdest);
     516                STADJUST(psh, amount, expdest);
    517517                varflags &= ~VSNUL;
    518518                if (c != 0)
    … …  
    593593        *loc = c;
    594594        amount = ((str - 1) - (loc - startp)) - expdest;
    595         STADJUST(amount, expdest);
     595        STADJUST(psh, amount, expdest);
    596596        while (loc != str - 1)
    597597                *startp++ = *loc++;
    … …  
    600600recordright:
    601601        amount = loc - expdest;
    602         STADJUST(amount, expdest);
    603         STPUTC('\0', expdest);
    604         STADJUST(-1, expdest);
     602        STADJUST(psh, amount, expdest);
     603        STPUTC(psh, '\0', expdest);
     604        STADJUST(psh, -1, expdest);
    605605        return 1;
    606606}
    … …  
    648648
    649649        varlen = 0;
    650         startloc = expdest - stackblock();
    651 
    652         if (!set && uflag) {
     650        startloc = expdest - stackblock(psh);
     651
     652        if (!set && uflag(psh)) {
    653653                switch (subtype) {
    654654                case VSNORMAL:
    … …  
    668668                        varvalue(var, varflags & VSQUOTE, subtype, flag);
    669669                        if (subtype == VSLENGTH) {
    670                                 varlen = expdest - stackblock() - startloc;
    671                                 STADJUST(-varlen, expdest);
     670                                varlen = expdest - stackblock(psh) - startloc;
     671                                STADJUST(psh, -varlen, expdest);
    672672                        }
    673673                } else {
    … …  
    681681                                while (*val) {
    682682                                        if (quotes && syntax[(int)*val] == CCTL)
    683                                                 STPUTC(CTLESC, expdest);
    684                                         STPUTC(*val++, expdest);
     683                                                STPUTC(psh, CTLESC, expdest);
     684                                        STPUTC(psh, *val++, expdest);
    685685                                }
    686686
    … …  
    727727                 * right after it
    728728                 */
    729                 STPUTC('\0', expdest);
    730                 patloc = expdest - stackblock();
     729                STPUTC(psh, '\0', expdest);
     730                patloc = expdest - stackblock(psh);
    731731                if (subevalvar(p, NULL, patloc, subtype,
    732732                               startloc, varflags) == 0) {
    733                         int amount = (expdest - stackblock() - patloc) + 1;
    734                         STADJUST(-amount, expdest);
     733                        int amount = (expdest - stackblock(psh) - patloc) + 1;
     734                        STADJUST(psh, -amount, expdest);
    735735                }
    736736                /* Remove any recorded regions beyond start of variable */
    … …  
    760760
    761761        if (apply_ifs)
    762                 recordregion(startloc, expdest - stackblock(),
     762                recordregion(startloc, expdest - stackblock(psh),
    763763                             varflags & VSQUOTE);
    764764
    … …  
    846846                while (*p) { \
    847847                        if (syntax[(int)*p] == CCTL) \
    848                                 STPUTC(CTLESC, expdest); \
    849                         STPUTC(*p++, expdest); \
     848                                STPUTC(psh, CTLESC, expdest); \
     849                        STPUTC(psh, *p++, expdest); \
    850850                } \
    851851        } else \
    852852                while (*p) \
    853                         STPUTC(*p++, expdest); \
     853                        STPUTC(psh, *p++, expdest); \
    854854        } while (0)
    855855
    … …  
    873873                for (i = 0; optlist[i].name; i++) {
    874874                        if (optlist[i].val)
    875                                 STPUTC(optlist[i].letter, expdest);
     875                                STPUTC(psh, optlist[i].letter, expdest);
    876876                }
    877877                break;
    … …  
    881881                                STRTODEST(p);
    882882                                if (*ap)
    883                                         STPUTC('\0', expdest);
     883                                        STPUTC(psh, '\0', expdest);
    884884                        }
    885885                        break;
    … …  
    894894                        STRTODEST(p);
    895895                        if (*ap && sep)
    896                                 STPUTC(sep, expdest);
     896                                STPUTC(psh, sep, expdest);
    897897                }
    898898                break;
    … …  
    969969        if (ifslastp == NULL) {
    970970                /* Return entire argument, IFS doesn't apply to any of it */
    971                 sp = (struct strlist *)stalloc(sizeof *sp);
     971                sp = (struct strlist *)stalloc(psh, sizeof *sp);
    972972                sp->text = start;
    973973                *arglist->lastp = sp;
    … …  
    10091009                        /* Save this argument... */
    10101010                        *q = '\0';
    1011                         sp = (struct strlist *)stalloc(sizeof *sp);
     1011                        sp = (struct strlist *)stalloc(psh, sizeof *sp);
    10121012                        sp->text = start;
    10131013                        *arglist->lastp = sp;
    … …  
    10431043         */
    10441044        if (*start /* || (!ifsspc && start > string) */) {
    1045                 sp = (struct strlist *)stalloc(sizeof *sp);
     1045                sp = (struct strlist *)stalloc(psh, sizeof *sp);
    10461046                sp->text = start;
    10471047                *arglist->lastp = sp;
    … …  
    10851085
    10861086        while (str) {
    1087                 if (fflag)
     1087                if (fflag(psh))
    10881088                        goto nometa;
    10891089                p = str->text;
    … …  
    12641264        struct strlist *sp;
    12651265
    1266         p = stalloc(strlen(name) + 1);
     1266        p = stalloc(psh, strlen(name) + 1);
    12671267        scopy(name, p);
    1268         sp = (struct strlist *)stalloc(sizeof *sp);
     1268        sp = (struct strlist *)stalloc(psh, sizeof *sp);
    12691269        sp->text = p;
    12701270        *exparg.lastp = sp;
    … …  
    15091509        char *p;
    15101510
    1511         setstackmark(&smark);
     1511        setstackmark(psh, &smark);
    15121512        argbackq = pattern->narg.backquote;
    1513         STARTSTACKSTR(expdest);
     1513        STARTSTACKSTR(psh, expdest);
    15141514        ifslastp = NULL;
    15151515        argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
    1516         STPUTC('\0', expdest);
    1517         p = grabstackstr(expdest);
     1516        STPUTC(psh, '\0', expdest);
     1517        p = grabstackstr(psh, expdest);
    15181518        result = patmatch(p, val, 0);
    1519         popstackmark(&smark);
     1519        popstackmark(psh, &smark);
    15201520        return result;
    15211521}
    … …  
    15421542
    15431543        while (*p)
    1544                 STPUTC(*p++, buf);
     1544                STPUTC(psh, *p++, buf);
    15451545        return buf;
    15461546}
Note: See TracChangeset for help on using the changeset viewer.