VirtualBox

Changeset 884 in kBuild for trunk


Ignore:
Timestamp:
Apr 21, 2007 10:17:42 PM (18 years ago)
Author:
bird
Message:

hacking...

Location:
trunk/src/ash-messup
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ash-messup/Makefile.kmk

    r882 r884  
    3030kmk_ash_INCS.win = win
    3131kmk_ash_SOURCES = \
     32        main.c \
    3233        alias.c \
    3334        cd.c \
    … …  
    4041        jobs.c \
    4142        mail.c \
    42         main.c \
    4343        memalloc.c \
    4444        miscbltin.c \

  • trunk/src/ash-messup/eval.c

    r883 r884  
    8787#include "myhistedit.h"
    8888#endif
     89#include "shinstance.h"
    8990
    9091
    … …  
    9495#define EV_BACKCMD 04           /* command executing within back quotes */
    9596
    96 int evalskip;                   /* set if we are skipping commands */
    97 STATIC int skipcount;           /* number of levels to skip */
    98 MKINIT int loopnest;            /* current loop nesting level */
    99 int funcnest;                   /* depth of function calls */
     97/*int evalskip;*/                       /* set if we are skipping commands */
     98/*STATIC int skipcount;*/               /* number of levels to skip */
     99/*MKINIT int loopnest;*/                /* current loop nesting level */
     100/*int funcnest;*/                       /* depth of function calls */
    100101
    101102
    102103/*char *commandname;*/
    103 struct strlist *cmdenviron;
    104 int exitstatus;                 /* exit status of last command */
    105 int back_exitstatus;            /* exit status of backquoted command */
    106 
    107 
    108 STATIC void evalloop(union node *, int);
    109 STATIC void evalfor(union node *, int);
    110 STATIC void evalcase(union node *, int);
    111 STATIC void evalsubshell(union node *, int);
    112 STATIC void expredir(union node *);
    113 STATIC void evalpipe(union node *);
    114 STATIC void evalcommand(union node *, int, struct backcmd *);
    115 STATIC void prehash(union node *);
     104/*struct strlist *cmdenviron;*/
     105/*int exitstatus;*/                     /* exit status of last command */
     106/*int back_exitstatus;*/                /* exit status of backquoted command */
     107
     108
     109STATIC void evalloop(shinstance *, union node *, int);
     110STATIC void evalfor(shinstance *, union node *, int);
     111STATIC void evalcase(shinstance *, union node *, int);
     112STATIC void evalsubshell(shinstance *, union node *, int);
     113STATIC void expredir(shinstance *, union node *);
     114STATIC void evalpipe(shinstance *, union node *);
     115STATIC void evalcommand(shinstance *, union node *, int, struct backcmd *);
     116STATIC void prehash(shinstance *, union node *);
    116117
    117118
    … …  
    135136
    136137static int
    137 sh_pipe(int fds[2])
     138sh_pipe(shinstance *psh, int fds[2])
    138139{
    139140        int nfd;
    140141
    141         if (pipe(fds))
     142        if (shfile_pipe(&psh->fdtab, fds))
    142143                return -1;
    143144
    144145        if (fds[0] < 3) {
    145                 nfd = fcntl(fds[0], F_DUPFD, 3);
     146                nfd = shfile_fcntl(&psh->fdtab, fds[0], F_DUPFD, 3);
    146147                if (nfd != -1) {
    147                         close(fds[0]);
     148                        shfile_close(&psh->fdtab, fds[0]);
    148149                        fds[0] = nfd;
    149150                }
    … …  
    151152
    152153        if (fds[1] < 3) {
    153                 nfd = fcntl(fds[1], F_DUPFD, 3);
     154                nfd = shfile_fcntl(&psh->fdtab, fds[1], F_DUPFD, 3);
    154155                if (nfd != -1) {
    155                         close(fds[1]);
     156                        shfile_close(&psh->fdtab, fds[1]);
    156157                        fds[1] = nfd;
    157158                }
    … …  
    166167
    167168int
    168 evalcmd(int argc, char **argv)
     169evalcmd(shinstance *psh, int argc, char **argv)
    169170{
    170171        char *p;
    … …  
    187188                        p = grabstackstr(concat);
    188189                }
    189                 evalstring(p, EV_TESTED);
     190                evalstring(psh, p, EV_TESTED);
    190191        }
    191         return exitstatus;
     192        return psh->exitstatus;
    192193}
    193194
    … …  
    198199
    199200void
    200 evalstring(char *s, int flag)
     201evalstring(shinstance *psh, char *s, int flag)
    201202{
    202203        union node *n;
    203204        struct stackmark smark;
    204205
    205         setstackmark(&smark);
    206         setinputstring(s, 1);
    207 
    208         while ((n = parsecmd(0)) != NEOF) {
    209                 evaltree(n, flag);
    210                 popstackmark(&smark);
    211         }
    212         popfile();
    213         popstackmark(&smark);
     206        setstackmark(psh, &smark);
     207        setinputstring(psh, s, 1);
     208
     209        while ((n = parsecmd(psh, 0)) != NEOF) {
     210                evaltree(psh, n, flag);
     211                popstackmark(psh, &smark);
     212        }
     213        popfile(psh);
     214        popstackmark(psh, &smark);
    214215}
    215216
    … …  
    222223
    223224void
    224 evaltree(union node *n, int flags)
     225evaltree(shinstance *psh, union node *n, int flags)
    225226{
    226227        if (n == NULL) {
    227228                TRACE(("evaltree(NULL) called\n"));
    228                 exitstatus = 0;
     229                psh->exitstatus = 0;
    229230                goto out;
    230231        }
    231232#ifndef SMALL
    232         displayhist = 1;        /* show history substitutions done with fc */
     233        psh->displayhist = 1;   /* show history substitutions done with fc */
    233234#endif
    234235        TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
    … …  
    236237        switch (n->type) {
    237238        case NSEMI:
    238                 evaltree(n->nbinary.ch1, flags & EV_TESTED);
    239                 if (evalskip)
     239                evaltree(psh, n->nbinary.ch1, flags & EV_TESTED);
     240                if (psh->evalskip)
    240241                        goto out;
    241                 evaltree(n->nbinary.ch2, flags);
     242                evaltree(psh, n->nbinary.ch2, flags);
    242243                break;
    243244        case NAND:
    244                 evaltree(n->nbinary.ch1, EV_TESTED);
    245                 if (evalskip || exitstatus != 0)
     245                evaltree(psh, n->nbinary.ch1, EV_TESTED);
     246                if (psh->evalskip || psh->exitstatus != 0)
    246247                        goto out;
    247                 evaltree(n->nbinary.ch2, flags);
     248                evaltree(psh, n->nbinary.ch2, flags);
    248249                break;
    249250        case NOR:
    250                 evaltree(n->nbinary.ch1, EV_TESTED);
    251                 if (evalskip || exitstatus == 0)
     251                evaltree(psh, n->nbinary.ch1, EV_TESTED);
     252                if (psh->evalskip || psh->exitstatus == 0)
    252253                        goto out;
    253                 evaltree(n->nbinary.ch2, flags);
     254                evaltree(psh, n->nbinary.ch2, flags);
    254255                break;
    255256        case NREDIR:
    256                 expredir(n->nredir.redirect);
    257                 redirect(n->nredir.redirect, REDIR_PUSH);
    258                 evaltree(n->nredir.n, flags);
    259                 popredir();
     257                expredir(psh, n->nredir.redirect);
     258                redirect(psh, n->nredir.redirect, REDIR_PUSH);
     259                evaltree(psh, n->nredir.n, flags);
     260                popredir(psh);
    260261                break;
    261262        case NSUBSHELL:
    262                 evalsubshell(n, flags);
     263                evalsubshell(psh, n, flags);
    263264                break;
    264265        case NBACKGND:
    265                 evalsubshell(n, flags);
     266                evalsubshell(psh, n, flags);
    266267                break;
    267268        case NIF: {
    268                 evaltree(n->nif.test, EV_TESTED);
    269                 if (evalskip)
     269                evaltree(psh, n->nif.test, EV_TESTED);
     270                if (psh->evalskip)
    270271                        goto out;
    271                 if (exitstatus == 0)
    272                         evaltree(n->nif.ifpart, flags);
     272                if (psh->exitstatus == 0)
     273                        evaltree(psh, n->nif.ifpart, flags);
    273274                else if (n->nif.elsepart)
    274                         evaltree(n->nif.elsepart, flags);
     275                        evaltree(psh, n->nif.elsepart, flags);
    275276                else
    276                         exitstatus = 0;
     277                        psh->exitstatus = 0;
    277278                break;
    278279        }
    279280        case NWHILE:
    280281        case NUNTIL:
    281                 evalloop(n, flags);
     282                evalloop(psh, n, flags);
    282283                break;
    283284        case NFOR:
    284                 evalfor(n, flags);
     285                evalfor(psh, n, flags);
    285286                break;
    286287        case NCASE:
    287                 evalcase(n, flags);
     288                evalcase(psh, n, flags);
    288289                break;
    289290        case NDEFUN:
    290                 defun(n->narg.text, n->narg.next);
    291                 exitstatus = 0;
     291                defun(psh, n->narg.text, n->narg.next);
     292                psh->exitstatus = 0;
    292293                break;
    293294        case NNOT:
    294                 evaltree(n->nnot.com, EV_TESTED);
    295                 exitstatus = !exitstatus;
     295                evaltree(psh, n->nnot.com, EV_TESTED);
     296                psh->exitstatus = !psh->exitstatus;
    296297                break;
    297298        case NPIPE:
    298                 evalpipe(n);
     299                evalpipe(psh, n);
    299300                break;
    300301        case NCMD:
    301                 evalcommand(n, flags, (struct backcmd *)NULL);
     302                evalcommand(psh, n, flags, (struct backcmd *)NULL);
    302303                break;
    303304        default:
    304                 out1fmt("Node type = %d\n", n->type);
    305                 flushout(&output);
     305                out1fmt(psh, "Node type = %d\n", n->type);
     306                flushout(&psh->output);
    306307                break;
    307308        }
    308309out:
    309         if (pendingsigs)
    310                 dotrap();
     310        if (psh->pendingsigs)
     311                dotrap(psh);
    311312        if ((flags & EV_EXIT) != 0)
    312                 exitshell(exitstatus);
     313                exitshell(psh, psh->exitstatus);
    313314}
    314315
    315316
    316317STATIC void
    317 evalloop(union node *n, int flags)
     318evalloop(shinstance *psh, union node *n, int flags)
    318319{
    319320        int status;
    320321
    321         loopnest++;
     322        psh->loopnest++;
    322323        status = 0;
    323324        for (;;) {
    324                 evaltree(n->nbinary.ch1, EV_TESTED);
    325                 if (evalskip) {
    326 skipping:         if (evalskip == SKIPCONT && --skipcount <= 0) {
    327                                 evalskip = 0;
     325                evaltree(psh, n->nbinary.ch1, EV_TESTED);
     326                if (psh->evalskip) {
     327skipping:         if (psh->evalskip == SKIPCONT && --psh->skipcount <= 0) {
     328                                psh->evalskip = 0;
    328329                                continue;
    329330                        }
    330                         if (evalskip == SKIPBREAK && --skipcount <= 0)
    331                                 evalskip = 0;
     331                        if (psh->evalskip == SKIPBREAK && --psh->skipcount <= 0)
     332                                psh->evalskip = 0;
    332333                        break;
    333334                }
    334335                if (n->type == NWHILE) {
    335                         if (exitstatus != 0)
     336                        if (psh->exitstatus != 0)
    336337                                break;
    337338                } else {
    338                         if (exitstatus == 0)
     339                        if (psh->exitstatus == 0)
    339340                                break;
    340341                }
    341                 evaltree(n->nbinary.ch2, flags & EV_TESTED);
    342                 status = exitstatus;
    343                 if (evalskip)
     342                evaltree(psh, n->nbinary.ch2, flags & EV_TESTED);
     343                status = psh->exitstatus;
     344                if (psh->evalskip)
    344345                        goto skipping;
    345346        }
    346         loopnest--;
    347         exitstatus = status;
     347        psh->loopnest--;
     348        psh->exitstatus = status;
    348349}
    349350
    … …  
    351352
    352353STATIC void
    353 evalfor(union node *n, int flags)
     354evalfor(shinstance *psh, union node *n, int flags)
    354355{
    355356        struct arglist arglist;
    … …  
    359360        int status = 0;
    360361
    361         setstackmark(&smark);
     362        setstackmark(psh, &smark);
    362363        arglist.lastp = &arglist.list;
    363364        for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
    364                 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
    365                 if (evalskip)
     365                expandarg(psh, argp, &arglist, EXP_FULL | EXP_TILDE);
     366                if (psh->evalskip)
    366367                        goto out;
    367368        }
    368369        *arglist.lastp = NULL;
    369370
    370         loopnest++;
     371        psh->loopnest++;
    371372        for (sp = arglist.list ; sp ; sp = sp->next) {
    372                 setvar(n->nfor.var, sp->text, 0);
    373                 evaltree(n->nfor.body, flags & EV_TESTED);
    374                 status = exitstatus;
    375                 if (evalskip) {
    376                         if (evalskip == SKIPCONT && --skipcount <= 0) {
    377                                 evalskip = 0;
     373                setvar(psh, n->nfor.var, sp->text, 0);
     374                evaltree(psh, n->nfor.body, flags & EV_TESTED);
     375                status = psh->exitstatus;
     376                if (psh->evalskip) {
     377                        if (psh->evalskip == SKIPCONT && --psh->skipcount <= 0) {
     378                                psh->evalskip = 0;
    378379                                continue;
    379380                        }
    380                         if (evalskip == SKIPBREAK && --skipcount <= 0)
    381                                 evalskip = 0;
     381                        if (psh->evalskip == SKIPBREAK && --psh->skipcount <= 0)
     382                                psh->evalskip = 0;
    382383                        break;
    383384                }
    384385        }
    385         loopnest--;
    386         exitstatus = status;
     386        psh->loopnest--;
     387        psh->exitstatus = status;
    387388out:
    388         popstackmark(&smark);
     389        popstackmark(psh, &smark);
    389390}
    390391
    … …  
    392393
    393394STATIC void
    394 evalcase(union node *n, int flags)
     395evalcase(shinstance *psh, union node *n, int flags)
    395396{
    396397        union node *cp;
    … …  
    400401        int status = 0;
    401402
    402         setstackmark(&smark);
     403        setstackmark(psh, &smark);
    403404        arglist.lastp = &arglist.list;
    404         expandarg(n->ncase.expr, &arglist, EXP_TILDE);
    405         for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
     405        expandarg(psh, n->ncase.expr, &arglist, EXP_TILDE);
     406        for (cp = n->ncase.cases ; cp && psh->evalskip == 0 ; cp = cp->nclist.next) {
    406407                for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
    407                         if (casematch(patp, arglist.list->text)) {
    408                                 if (evalskip == 0) {
    409                                         evaltree(cp->nclist.body, flags);
    410                                         status = exitstatus;
     408                        if (casematch(psh, patp, arglist.list->text)) {
     409                                if (psh->evalskip == 0) {
     410                                        evaltree(psh, cp->nclist.body, flags);
     411                                        status = psh->exitstatus;
    411412                                }
    412413                                goto out;
    … …  
    415416        }
    416417out:
    417         exitstatus = status;
    418         popstackmark(&smark);
     418        psh->exitstatus = status;
     419        popstackmark(psh, &smark);
    419420}
    420421
    … …  
    426427
    427428STATIC void
    428 evalsubshell(union node *n, int flags)
     429evalsubshell(shinstance *psh, union node *n, int flags)
    429430{
    430431        struct job *jp;
    431432        int backgnd = (n->type == NBACKGND);
    432433
    433         expredir(n->nredir.redirect);
     434        expredir(psh, n->nredir.redirect);
    434435        INTOFF;
    435         jp = makejob(n, 1);
    436         if (forkshell(jp, n, backgnd ? FORK_BG : FORK_FG) == 0) {
     436        jp = makejob(psh, n, 1);
     437        if (forkshell(psh, jp, n, backgnd ? FORK_BG : FORK_FG) == 0) {
    437438                INTON;
    438439                if (backgnd)
    439440                        flags &=~ EV_TESTED;
    440                 redirect(n->nredir.redirect, 0);
     441                redirect(psh, n->nredir.redirect, 0);
    441442                /* never returns */
    442                 evaltree(n->nredir.n, flags | EV_EXIT);
     443                evaltree(psh, n->nredir.n, flags | EV_EXIT);
    443444        }
    444445        if (! backgnd)
    445                 exitstatus = waitforjob(jp);
     446                psh->exitstatus = waitforjob(psh, jp);
    446447        INTON;
    447448}
    … …  
    454455
    455456STATIC void
    456 expredir(union node *n)
     457expredir(shinstance *psh, union node *n)
    457458{
    458459        union node *redir;
    … …  
    467468                case NCLOBBER:
    468469                case NAPPEND:
    469                         expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
     470                        expandarg(psh, redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
    470471                        redir->nfile.expfname = fn.list->text;
    471472                        break;
    … …  
    473474                case NTOFD:
    474475                        if (redir->ndup.vname) {
    475                                 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
    476                                 fixredir(redir, fn.list->text, 1);
     476                                expandarg(psh, redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
     477                                fixredir(psh, redir, fn.list->text, 1);
    477478                        }
    478479                        break;
    … …  
    491492
    492493STATIC void
    493 evalpipe(union node *n)
     494evalpipe(shinstance *psh, union node *n)
    494495{
    495496        struct job *jp;
    … …  
    504505                pipelen++;
    505506        INTOFF;
    506         jp = makejob(n, pipelen);
     507        jp = makejob(psh, n, pipelen);
    507508        prevfd = -1;
    508509        for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
    509                 prehash(lp->n);
     510                prehash(psh, lp->n);
    510511                pip[1] = -1;
    511512                if (lp->next) {
    512                         if (sh_pipe(pip) < 0) {
    513                                 close(prevfd);
    514                                 error("Pipe call failed");
    515                         }
    516                 }
    517                 if (forkshell(jp, lp->n, n->npipe.backgnd ? FORK_BG : FORK_FG) == 0) {
     513                        if (sh_pipe(psh, pip) < 0) {
     514                                shfile_close(&psh->fdtab, prevfd);
     515                                error(psh, "Pipe call failed");
     516                        }
     517                }
     518                if (forkshell(psh, jp, lp->n, n->npipe.backgnd ? FORK_BG : FORK_FG) == 0) {
    518519                        INTON;
    519520                        if (prevfd > 0) {
    520                                 close(0);
    521                                 copyfd(prevfd, 0);
    522                                 close(prevfd);
     521                                shfile_close(&psh->fdtab, 0);
     522                                copyfd(psh, prevfd, 0);
     523                                shfile_close(&psh->fdtab, prevfd);
    523524                        }
    524525                        if (pip[1] >= 0) {
    525                                 close(pip[0]);
     526                                shfile_close(&psh->fdtab, pip[0]);
    526527                                if (pip[1] != 1) {
    527                                         close(1);
    528                                         copyfd(pip[1], 1);
    529                                         close(pip[1]);
     528                                        shfile_close(&psh->fdtab, 1);
     529                                        copyfd(psh, pip[1], 1);
     530                                        shfile_close(&psh->fdtab, pip[1]);
    530531                                }
    531532                        }
    532                         evaltree(lp->n, EV_EXIT);
     533                        evaltree(psh, lp->n, EV_EXIT);
    533534                }
    534535                if (prevfd >= 0)
    535                         close(prevfd);
     536                        shfile_close(&psh->fdtab, prevfd);
    536537                prevfd = pip[0];
    537                 close(pip[1]);
     538                shfile_close(&psh->fdtab, pip[1]);
    538539        }
    539540        if (n->npipe.backgnd == 0) {
    540                 exitstatus = waitforjob(jp);
    541                 TRACE(("evalpipe:  job done exit status %d\n", exitstatus));
     541                psh->exitstatus = waitforjob(psh, jp);
     542                TRACE(("evalpipe:  job done exit status %d\n", psh->exitstatus));
    542543        }
    543544        INTON;
    … …  
    554555
    555556void
    556 evalbackcmd(union node *n, struct backcmd *result)
     557evalbackcmd(shinstance *psh, union node *n, struct backcmd *result)
    557558{
    558559        int pip[2];
    … …  
    560561        struct stackmark smark;         /* unnecessary */
    561562
    562         setstackmark(&smark);
     563        setstackmark(psh, &smark);
    563564        result->fd = -1;
    564565        result->buf = NULL;
    … …  
    576577         */
    577578        if (n->type == NCMD) {
    578                 exitstatus = oexitstatus;
    579                 evalcommand(n, EV_BACKCMD, result);
     579                psh->exitstatus = opsh->exitstatus;
     580                evalcommand(psh, n, EV_BACKCMD, result);
    580581        } else
    581582#endif
    582583        {
    583584                INTOFF;
    584                 if (sh_pipe(pip) < 0)
    585                         error("Pipe call failed");
    586                 jp = makejob(n, 1);
    587                 if (forkshell(jp, n, FORK_NOJOB) == 0) {
     585                if (sh_pipe(psh, pip) < 0)
     586                        error(psh, "Pipe call failed");
     587                jp = makejob(psh, n, 1);
     588                if (forkshell(psh, jp, n, FORK_NOJOB) == 0) {
    588589                        FORCEINTON;
    589                         close(pip[0]);
     590                        shfile_close(&psh->fdtab, pip[0]);
    590591                        if (pip[1] != 1) {
    591                                 close(1);
    592                                 copyfd(pip[1], 1);
    593                                 close(pip[1]);
    594                         }
    595                         eflag = 0;
    596                         evaltree(n, EV_EXIT);
     592                                shfile_close(&psh->fdtab, 1);
     593                                copyfd(psh, pip[1], 1);
     594                                shfile_close(&psh->fdtab, pip[1]);
     595                        }
     596                        psh->eflag = 0;
     597                        evaltree(psh, n, EV_EXIT);
    597598                        /* NOTREACHED */
    598599                }
    599                 close(pip[1]);
     600                shfile_close(&psh->fdtab, pip[1]);
    600601                result->fd = pip[0];
    601602                result->jp = jp;
    … …  
    603604        }
    604605out:
    605         popstackmark(&smark);
     606        popstackmark(psh, &smark);
    606607        TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
    607608                result->fd, result->buf, result->nleft, result->jp));
    … …  
    609610
    610611static const char *
    611 syspath(void)
     612syspath(shinstance *psh)
    612613{
    613614#ifdef CTL_USER
    … …  
    641642
    642643static int
    643 parse_command_args(int argc, char **argv, int *use_syspath)
     644parse_command_args(shinstance *psh, int argc, char **argv, int *use_syspath)
    644645{
    645646        int sv_argc = argc;
    … …  
    674675}
    675676
    676 int vforked = 0;
     677/*int vforked = 0;*/
    677678
    678679/*
    … …  
    681682
    682683STATIC void
    683 evalcommand(union node *cmd, int flags, struct backcmd *backcmd)
     684evalcommand(shinstance *psh, union node *cmd, int flags, struct backcmd *backcmd)
    684685{
    685686        struct stackmark smark;
    … …  
    703704        volatile int e;
    704705        char *lastarg;
    705         const char *path = pathval();
     706        const char *path = pathval(psh);
    706707        volatile int temp_path;
    707708#if __GNUC__
    … …  
    713714#endif
    714715
    715         vforked = 0;
     716        psh->vforked = 0;
    716717        /* First expand the arguments. */
    717718        TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
    718         setstackmark(&smark);
    719         back_exitstatus = 0;
     719        setstackmark(psh, &smark);
     720        psh->exitstatus = 0;
    720721
    721722        arglist.lastp = &arglist.list;
    … …  
    731732                                continue;
    732733                }
    733                 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
     734                expandarg(psh, argp, &arglist, EXP_FULL | EXP_TILDE);
    734735                varflag = 0;
    735736        }
    736737        *arglist.lastp = NULL;
    737738
    738         expredir(cmd->ncmd.redirect);
     739        expredir(psh, cmd->ncmd.redirect);
    739740
    740741        /* Now do the initial 'name=value' ones we skipped above */
    … …  
    749750                if (*p != '=')
    750751                        break;
    751                 expandarg(argp, &varlist, EXP_VARTILDE);
     752                expandarg(psh, argp, &varlist, EXP_VARTILDE);
    752753        }
    753754        *varlist.lastp = NULL;
    … …  
    756757        for (sp = arglist.list ; sp ; sp = sp->next)
    757758                argc++;
    758         argv = stalloc(sizeof (char *) * (argc + 1));
     759        argv = stalloc(psh, sizeof (char *) * (argc + 1));
    759760
    760761        for (sp = arglist.list ; sp ; sp = sp->next) {
    … …  
    764765        *argv = NULL;
    765766        lastarg = NULL;
    766         if (iflag && funcnest == 0 && argc > 0)
     767        if (psh->iflag && psh->funcnest == 0 && argc > 0)
    767768                lastarg = argv[-1];
    768769        argv -= argc;
    769770
    770771        /* Print the command if xflag is set. */
    771         if (xflag) {
     772        if (psh->xflag) {
    772773                char sep = 0;
    773                 out2str(ps4val());
     774                out2str(psh, ps4val(psh));
    774775                for (sp = varlist.list ; sp ; sp = sp->next) {
    775776                        if (sep != 0)
    776                                 outc(sep, &errout);
    777                         out2str(sp->text);
     777                                outc(sep, &psh->errout);
     778                        out2str(psh, sp->text);
    778779                        sep = ' ';
    779780                }
    780781                for (sp = arglist.list ; sp ; sp = sp->next) {
    781782                        if (sep != 0)
    782                                 outc(sep, &errout);
    783                         out2str(sp->text);
     783                                outc(sep, &psh->errout);
     784                        out2str(psh, sp->text);
    784785                        sep = ' ';
    785786                }
    786                 outc('\n', &errout);
    787                 flushout(&errout);
     787                outc('\n', &psh->errout);
     788                flushout(&psh->errout);
    788789        }
    789790
    … …  
    806807                do {
    807808                        int argsused, use_syspath;
    808                         find_command(argv[0], &cmdentry, cmd_flags, path);
     809                        find_command(psh, argv[0], &cmdentry, cmd_flags, path);
    809810                        if (cmdentry.cmdtype == CMDUNKNOWN) {
    810                                 exitstatus = 127;
    811                                 flushout(&errout);
     811                                psh->exitstatus = 127;
     812                                flushout(&psh->errout);
    812813                                goto out;
    813814                        }
    … …  
    818819                                break;
    819820                        cmd_flags |= DO_NOFUNC;
    820                         argsused = parse_command_args(argc, argv, &use_syspath);
     821                        argsused = parse_command_args(psh, argc, argv, &use_syspath);
    821822                        if (argsused == 0) {
    822823                                /* use 'type' builting to display info */
    … …  
    827828                        argv += argsused;
    828829                        if (use_syspath)
    829                                 path = syspath() + 5;
     830                                path = syspath(psh) + 5;
    830831                } while (argc != 0);
    831832                if (cmdentry.cmdtype == CMDSPLBLTIN && cmd_flags & DO_NOFUNC)
    … …  
    843844                 || cmdentry.u.bltin == evalcmd))) {
    844845                INTOFF;
    845                 jp = makejob(cmd, 1);
     846                jp = makejob(psh, cmd, 1);
    846847                mode = cmd->ncmd.backgnd;
    847848                if (flags & EV_BACKCMD) {
    848849                        mode = FORK_NOJOB;
    849                         if (sh_pipe(pip) < 0)
    850                                 error("Pipe call failed");
     850                        if (sh_pipe(psh, pip) < 0)
     851                                error(psh, "Pipe call failed");
    851852                }
    852853#ifdef DO_SHAREDVFORK
    … …  
    858859                        pid_t   pid;
    859860
    860                         savelocalvars = localvars;
    861                         localvars = NULL;
    862                         vforked = 1;
     861                        savelocalvars = psh->localvars;
     862                        psh->localvars = NULL;
     863                        psh->vforked = 1;
    863864                        switch (pid = vfork()) {
    864865                        case -1:
    865866                                TRACE(("Vfork failed, errno=%d\n", errno));
    866867                                INTON;
    867                                 error("Cannot vfork");
     868                                error(psh, "Cannot vfork");
    868869                                break;
    869870                        case 0:
    … …  
    872873                                 */
    873874                                if (setjmp(jmploc.loc)) {
    874                                         if (exception == EXSHELLPROC) {
     875                                        if (psh->exception == EXSHELLPROC) {
    875876                                                /* We can't progress with the vfork,
    876877                                                 * so, set vforked = 2 so the parent
    877878                                                 * knows, and _exit();
    878879                                                 */
    879                                                 vforked = 2;
    880                                                 _exit(0);
     880                                                psh->vforked = 2;
     881                                                sh__exit(psh, 0);
    881882                                        } else {
    882                                                 _exit(exerrno);
     883                                                sh__exit(psh, exerrno);
    883884                                        }
    884885                                }
    885                                 savehandler = handler;
    886                                 handler = &jmploc;
    887                                 listmklocal(varlist.list, VEXPORT | VNOFUNC);
    888                                 forkchild(jp, cmd, mode, vforked);
     886                                savehandler = psh->handler;
     887                                psh->handler = &jmploc;
     888                                listmklocal(psh, varlist.list, VEXPORT | VNOFUNC);
     889                                forkchild(psh, jp, cmd, mode, psh->vforked);
    889890                                break;
    890891                        default:
    891                                 handler = savehandler;  /* restore from vfork(2) */
    892                                 poplocalvars();
    893                                 localvars = savelocalvars;
    894                                 if (vforked == 2) {
    895                                         vforked = 0;
    896 
    897                                         (void)waitpid(pid, NULL, 0);
     892                                psh->handler = savehandler;     /* restore from vfork(2) */
     893                                poplocalvars(psh);
     894                                psh->localvars = savelocalvars;
     895                                if (psh->vforked == 2) {
     896                                        psh->vforked = 0;
     897
     898                                        (void)sh_waitpid(psh, pid, NULL, 0);
    898899                                        /* We need to progress in a normal fork fashion */
    899900                                        goto normal_fork;
    900901                                }
    901                                 vforked = 0;
    902                                 forkparent(jp, cmd, mode, pid);
     902                                psh->vforked = 0;
     903                                forkparent(psh, jp, cmd, mode, pid);
    903904                                goto parent;
    904905                        }
    … …  
    906907normal_fork:
    907908#endif
    908                         if (forkshell(jp, cmd, mode) != 0)
     909                        if (forkshell(psh, jp, cmd, mode) != 0)
    909910                                goto parent;    /* at end of routine */
    910911                        FORCEINTON;
    … …  
    913914#endif
    914915                if (flags & EV_BACKCMD) {
    915                         if (!vforked) {
     916                        if (!psh->vforked) {
    916917                                FORCEINTON;
    917918                        }
    918                         close(pip[0]);
     919                        shfile_close(&psh->fdtab, pip[0]);
    919920                        if (pip[1] != 1) {
    920                                 close(1);
    921                                 copyfd(pip[1], 1);
    922                                 close(pip[1]);
     921                                shfile_close(&psh->fdtab, 1);
     922                                copyfd(psh, pip[1], 1);
     923                                shfile_close(&psh->fdtab, pip[1]);
    923924                        }
    924925                }
    … …  
    933934                trputs("Shell function:  ");  trargs(argv);
    934935#endif
    935                 redirect(cmd->ncmd.redirect, REDIR_PUSH);
    936                 saveparam = shellparam;
    937                 shellparam.malloc = 0;
    938                 shellparam.reset = 1;
    939                 shellparam.nparam = argc - 1;
    940                 shellparam.p = argv + 1;
    941                 shellparam.optnext = NULL;
     936                redirect(psh, cmd->ncmd.redirect, REDIR_PUSH);
     937                saveparam = psh->shellparam;
     938                psh->shellparam.malloc = 0;
     939                psh->shellparam.reset = 1;
     940                psh->shellparam.nparam = argc - 1;
     941                psh->shellparam.p = argv + 1;
     942                psh->shellparam.optnext = NULL;
    942943                INTOFF;
    943                 savelocalvars = localvars;
    944                 localvars = NULL;
     944                savelocalvars = psh->localvars;
     945                psh->localvars = NULL;
    945946                INTON;
    946947                if (setjmp(jmploc.loc)) {
    947                         if (exception == EXSHELLPROC) {
     948                        if (psh->exception == EXSHELLPROC) {
    948949                                freeparam((volatile struct shparam *)
    949950                                    &saveparam);
    950951                        } else {
    951                                 freeparam(&shellparam);
    952                                 shellparam = saveparam;
    953                         }
    954                         poplocalvars();
    955                         localvars = savelocalvars;
    956                         handler = savehandler;
    957                         longjmp(handler->loc, 1);
    958                 }
    959                 savehandler = handler;
    960                 handler = &jmploc;
    961                 listmklocal(varlist.list, 0);
     952                                freeparam(&psh->shellparam);
     953                                psh->shellparam = saveparam;
     954                        }
     955                        poplocalvars(psh);
     956                        psh->localvars = savelocalvars;
     957                        psh->handler = savehandler;
     958                        longjmp(psh->handler->loc, 1);
     959                }
     960                savehandler = psh->handler;
     961                psh->handler = &jmploc;
     962                listmklocal(psh, varlist.list, 0);
    962963                /* stop shell blowing its stack */
    963                 if (++funcnest > 1000)
    964                         error("too many nested function calls");
    965                 evaltree(cmdentry.u.func, flags & EV_TESTED);
    966                 funcnest--;
     964                if (++psh->funcnest > 1000)
     965                        error(psh, "too many nested function calls");
     966                evaltree(psh, cmdentry.u.func, flags & EV_TESTED);
     967                psh->funcnest--;
    967968                INTOFF;
    968                 poplocalvars();
    969                 localvars = savelocalvars;
    970                 freeparam(&shellparam);
    971                 shellparam = saveparam;
    972                 handler = savehandler;
    973                 popredir();
     969                poplocalvars(psh);
     970                psh->localvars = savelocalvars;
     971                freeparam(&psh->shellparam);
     972                psh->shellparam = saveparam;
     973                psh->handler = savehandler;
     974                popredir(psh);
    974975                INTON;
    975                 if (evalskip == SKIPFUNC) {
    976                         evalskip = 0;
    977                         skipcount = 0;
     976                if (psh->evalskip == SKIPFUNC) {
     977                        psh->evalskip = 0;
     978                        psh->skipcount = 0;
    978979                }
    979980                if (flags & EV_EXIT)
    980                         exitshell(exitstatus);
     981                        exitshell(psh, psh->exitstatus);
    981982                break;
    982983
    … …  
    988989                mode = (cmdentry.u.bltin == execcmd) ? 0 : REDIR_PUSH;
    989990                if (flags == EV_BACKCMD) {
    990                         memout.nleft = 0;
    991                         memout.nextc = memout.buf;
    992                         memout.bufsize = 64;
     991                        psh->memout.nleft = 0;
     992                        psh->memout.nextc = psh->memout.buf;
     993                        psh->memout.bufsize = 64;
    993994                        mode |= REDIR_BACKQ;
    994995                }
    995996                e = -1;
    996                 savehandler = handler;
    997                 savecmdname = commandname;
    998                 handler = &jmploc;
     997                savehandler = psh->handler;
     998                savecmdname = psh->commandname;
     999                psh->handler = &jmploc;
    9991000                if (!setjmp(jmploc.loc)) {
    10001001                        /* We need to ensure the command hash table isn't
    … …  
    10021003                         * However we must ensure the 'local' command works!
    10031004                         */
    1004                         if (path != pathval() && (cmdentry.u.bltin == hashcmd ||
     1005                        if (path != pathval(psh) && (cmdentry.u.bltin == hashcmd ||
    10051006                            cmdentry.u.bltin == typecmd)) {
    1006                                 savelocalvars = localvars;
    1007                                 localvars = 0;
    1008                                 mklocal(path - 5 /* PATH= */, 0);
     1007                                savelocalvars = psh->localvars;
     1008                                psh->localvars = 0;
     1009                                mklocal(psh, path - 5 /* PATH= */, 0);
    10091010                                temp_path = 1;
    10101011                        } else
    10111012                                temp_path = 0;
    1012                         redirect(cmd->ncmd.redirect, mode);
     1013                        redirect(psh, cmd->ncmd.redirect, mode);
    10131014
    10141015                        /* exec is a special builtin, but needs this list... */
    1015                         cmdenviron = varlist.list;
     1016                        psh->cmdenviron = varlist.list;
    10161017                        /* we must check 'readonly' flag for all builtins */
    1017                         listsetvar(varlist.list,
     1018                        listsetvar(psh, varlist.list,
    10181019                                cmdentry.cmdtype == CMDSPLBLTIN ? 0 : VNOSET);
    1019                         commandname = argv[0];
     1020                        psh->commandname = argv[0];
    10201021                        /* initialize nextopt */
    1021                         argptr = argv + 1;
    1022                         optptr = NULL;
     1022                        psh->argptr = argv + 1;
     1023                        psh->optptr = NULL;
    10231024                        /* and getopt */
     1025/** @todo fix getop usage! */
    10241026#if defined(__FreeBSD__) || defined(__EMX__) || defined(__APPLE__)
    10251027                        optreset = 1;
    … …  
    10291031#endif
    10301032
    1031                         exitstatus = cmdentry.u.bltin(argc, argv);
     1033                        psh->exitstatus = cmdentry.u.bltin(psh, argc, argv);
    10321034                } else {
    1033                         e = exception;
    1034                         exitstatus = e == EXINT ? SIGINT + 128 :
    1035                                         e == EXEXEC ? exerrno : 2;
    1036                 }
    1037                 handler = savehandler;
    1038                 output_flushall();
    1039                 out1 = &output;
    1040                 out2 = &errout;
    1041                 freestdout();
     1035                        e = psh->exception;
     1036                        psh->exitstatus = e == EXINT ? SIGINT + 128 :
     1037                                        e == EXEXEC ? psh->exerrno : 2;
     1038                }
     1039                psh->handler = savehandler;
     1040                output_flushall(psh);
     1041                psh->out1 = &psh->output;
     1042                psh->out2 = &psh->errout;
     1043                freestdout(psh);
    10421044                if (temp_path) {
    1043                         poplocalvars();
    1044                         localvars = savelocalvars;
    1045                 }
    1046                 cmdenviron = NULL;
     1045                        poplocalvars(psh);
     1046                        psh->localvars = savelocalvars;
     1047                }
     1048                psh->cmdenviron = NULL;
    10471049                if (e != EXSHELLPROC) {
    1048                         commandname = savecmdname;
     1050                        psh->commandname = savecmdname;
    10491051                        if (flags & EV_EXIT)
    1050                                 exitshell(exitstatus);
     1052                                exitshell(psh, psh->exitstatus);
    10511053                }
    10521054                if (e != -1) {
    10531055                        if ((e != EXERROR && e != EXEXEC)
    10541056                            || cmdentry.cmdtype == CMDSPLBLTIN)
    1055                                 exraise(e);
     1057                                exraise(psh, e);
    10561058                        FORCEINTON;
    10571059                }
    10581060                if (cmdentry.u.bltin != execcmd)
    1059                         popredir();
     1061                        popredir(psh);
    10601062                if (flags == EV_BACKCMD) {
    1061                         backcmd->buf = memout.buf;
    1062                         backcmd->nleft = memout.nextc - memout.buf;
    1063                         memout.buf = NULL;
     1063                        backcmd->buf = psh->memout.buf;
     1064                        backcmd->nleft = psh->memout.nextc - psh->memout.buf;
     1065                        psh->memout.buf = NULL;
    10641066                }
    10651067                break;
    … …  
    10691071                trputs("normal command:  ");  trargs(argv);
    10701072#endif
    1071                 clearredir(vforked);
    1072                 redirect(cmd->ncmd.redirect, vforked ? REDIR_VFORK : 0);
    1073                 if (!vforked)
     1073                clearredir(psh, psh->vforked);
     1074                redirect(psh, cmd->ncmd.redirect, psh->vforked ? REDIR_VFORK : 0);
     1075                if (!psh->vforked)
    10741076                        for (sp = varlist.list ; sp ; sp = sp->next)
    1075                                 setvareq(sp->text, VEXPORT|VSTACK);
    1076                 envp = environment();
    1077                 shellexec(argv, envp, path, cmdentry.u.index, vforked);
     1077                                setvareq(psh, sp->text, VEXPORT|VSTACK);
     1078                envp = environment(psh);
     1079                shellexec(psh, argv, envp, path, cmdentry.u.index, psh->vforked);
    10781080                break;
    10791081        }
    … …  
    10821084parent: /* parent process gets here (if we forked) */
    10831085        if (mode == FORK_FG) {  /* argument to fork */
    1084                 exitstatus = waitforjob(jp);
     1086                psh->exitstatus = waitforjob(psh, jp);
    10851087        } else if (mode == FORK_NOJOB) {
    10861088                backcmd->fd = pip[0];
    1087                 close(pip[1]);
     1089                shfile_close(&psh->fdtab, pip[1]);
    10881090                backcmd->jp = jp;
    10891091        }
    … …  
    10961098                 * However I implemented that within libedit itself.
    10971099                 */
    1098                 setvar("_", lastarg, 0);
    1099         popstackmark(&smark);
    1100 
    1101         if (eflag && exitstatus && !(flags & EV_TESTED))
    1102                 exitshell(exitstatus);
     1100                setvar(psh, "_", lastarg, 0);
     1101        popstackmark(psh, &smark);
     1102
     1103        if (psh->eflag && psh->exitstatus && !(flags & EV_TESTED))
     1104                exitshell(psh, psh->exitstatus);
    11031105}
    11041106
    … …  
    11121114
    11131115STATIC void
    1114 prehash(union node *n)
     1116prehash(shinstance *psh, union node *n)
    11151117{
    11161118        struct cmdentry entry;
    … …  
    11181120        if (n->type == NCMD && n->ncmd.args)
    11191121                if (goodname(n->ncmd.args->narg.text))
    1120                         find_command(n->ncmd.args->narg.text, &entry, 0,
    1121                                      pathval());
     1122                        find_command(psh, n->ncmd.args->narg.text, &entry, 0,
     1123                                     pathval(psh));
    11221124}
    11231125
    … …  
    11341136
    11351137int
    1136 bltincmd(int argc, char **argv)
     1138bltincmd(shinstance *psh, int argc, char **argv)
    11371139{
    11381140        /*
    1139          * Preserve exitstatus of a previous possible redirection
     1141         * Preserve psh->exitstatus of a previous possible redirection
    11401142         * as POSIX mandates
    11411143         */
    1142         return back_exitstatus;
     1144        return psh->exitstatus;
    11431145}
    11441146
    … …  
    11461148/*
    11471149 * Handle break and continue commands.  Break, continue, and return are
    1148  * all handled by setting the evalskip flag.  The evaluation routines
     1150 * all handled by setting the psh->evalskip flag.  The evaluation routines
    11491151 * above all check this flag, and if it is set they start skipping
    11501152 * commands rather than executing them.  The variable skipcount is
    … …  
    11561158
    11571159int
    1158 breakcmd(int argc, char **argv)
     1160breakcmd(shinstance *psh, int argc, char **argv)
    11591161{
    11601162        int n = argc > 1 ? number(argv[1]) : 1;
    11611163
    1162         if (n > loopnest)
    1163                 n = loopnest;
     1164        if (n > psh->loopnest)
     1165                n = psh->loopnest;
    11641166        if (n > 0) {
    1165                 evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
    1166                 skipcount = n;
     1167                psh->evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
     1168                psh->skipcount = n;
    11671169        }
    11681170        return 0;
    … …  
    11751177
    11761178int
    1177 returncmd(int argc, char **argv)
    1178 {
    1179         int ret = argc > 1 ? number(argv[1]) : exitstatus;
    1180 
    1181         if (funcnest) {
    1182                 evalskip = SKIPFUNC;
    1183                 skipcount = 1;
     1179returncmd(shinstance *psh, int argc, char **argv)
     1180{
     1181        int ret = argc > 1 ? number(argv[1]) : psh->exitstatus;
     1182
     1183        if (psh->funcnest) {
     1184                psh->evalskip = SKIPFUNC;
     1185                psh->skipcount = 1;
    11841186                return ret;
    11851187        }
    11861188        else {
    11871189                /* Do what ksh does; skip the rest of the file */
    1188                 evalskip = SKIPFILE;
    1189                 skipcount = 1;
     1190                psh->evalskip = SKIPFILE;
     1191                psh->skipcount = 1;
    11901192                return ret;
    11911193        }
    … …  
    11941196
    11951197int
    1196 falsecmd(int argc, char **argv)
     1198falsecmd(shinstance *psh, int argc, char **argv)
    11971199{
    11981200        return 1;
    … …  
    12011203
    12021204int
    1203 truecmd(int argc, char **argv)
     1205truecmd(shinstance *psh, int argc, char **argv)
    12041206{
    12051207        return 0;
    … …  
    12081210
    12091211int
    1210 execcmd(int argc, char **argv)
     1212execcmd(shinstance *psh, int argc, char **argv)
    12111213{
    12121214        if (argc > 1) {
    12131215                struct strlist *sp;
    12141216
    1215                 iflag = 0;              /* exit on error */
    1216                 mflag = 0;
    1217                 optschanged();
    1218                 for (sp = cmdenviron; sp; sp = sp->next)
    1219                         setvareq(sp->text, VEXPORT|VSTACK);
    1220                 shellexec(argv + 1, environment(), pathval(), 0, 0);
     1217                psh->iflag = 0;         /* exit on error */
     1218                psh->mflag = 0;
     1219                optschanged(psh);
     1220                for (sp = psh->cmdenviron; sp; sp = sp->next)
     1221                        setvareq(psh, sp->text, VEXPORT|VSTACK);
     1222                shellexec(psh, argv + 1, environment(psh), pathval(psh), 0, 0);
    12211223        }
    12221224        return 0;
    … …  
    12311233
    12321234        if (!tpm)
    1233                 tpm = sysconf(_SC_CLK_TCK) * 60;
     1235                tpm = /*sysconf(_SC_CLK_TCK)*/sh_sysconf_clk_tck() * 60;
    12341236
    12351237        mins = ticks / tpm;
    … …  
    12511253
    12521254int
    1253 timescmd(int argc, char **argv)
    1254 {
    1255         struct tms tms;
     1255timescmd(shinstance *psh, int argc, char **argv)
     1256{
     1257        struct sh_tms tms;
    12561258        int u, s, cu, cs;
    12571259        char us[8], ss[8], cus[8], css[8];
    12581260
    1259         nextopt("");
    1260 
    1261         times(&tms);
     1261        nextopt(psh, "");
     1262
     1263        sh_times(&tms);
    12621264
    12631265        u = conv_time(tms.tms_utime, us, sizeof(us));
    … …  
    12661268        cs = conv_time(tms.tms_cstime, css, sizeof(css));
    12671269
    1268         outfmt(out1, "%dm%ss %dm%ss\n%dm%ss %dm%ss\n",
     1270        outfmt(psh->out1, "%dm%ss %dm%ss\n%dm%ss %dm%ss\n",
    12691271                u, us, s, ss, cu, cus, cs, css);
    12701272

  • trunk/src/ash-messup/exec.h

    r879 r884  
    4747        union param {
    4848                int index;
    49                 int (*bltin)(int, char**);
     49                int (*bltin)(struct shinstance*, int, char**);
    5050                union node *func;
    5151        } u;

  • trunk/src/ash-messup/expand.h

    r879 r884  
    6868/* From arith.y */
    6969int arith(const char *);
    70 int expcmd(int , char **);
     70int expcmd(struct shinstance *, int , char **);
    7171void arith_lex_reset(void);
    7272int yylex(void);

  • trunk/src/ash-messup/generated/builtins.h

    r631 r884  
    77struct builtincmd {
    88      const char *name;
    9       int (*builtin)(int, char **);
     9      int (*builtin)(struct shinstance *, int, char **);
    1010};
    1111
    … …  
    1414
    1515
    16 int bltincmd(int, char **);
    17 int bgcmd(int, char **);
    18 int breakcmd(int, char **);
    19 int cdcmd(int, char **);
    20 int dotcmd(int, char **);
    21 int echocmd(int, char **);
    22 int evalcmd(int, char **);
    23 int execcmd(int, char **);
    24 int exitcmd(int, char **);
    25 int expcmd(int, char **);
    26 int exportcmd(int, char **);
    27 int falsecmd(int, char **);
    28 int histcmd(int, char **);
    29 int inputrc(int, char **);
    30 int fgcmd(int, char **);
    31 int getoptscmd(int, char **);
    32 int hashcmd(int, char **);
    33 int jobidcmd(int, char **);
    34 int jobscmd(int, char **);
    35 int localcmd(int, char **);
     16int bltincmd(struct shinstance *, int, char **);
     17int bgcmd(struct shinstance *, int, char **);
     18int breakcmd(struct shinstance *, int, char **);
     19int cdcmd(struct shinstance *, int, char **);
     20int dotcmd(struct shinstance *, int, char **);
     21int echocmd(struct shinstance *, int, char **);
     22int evalcmd(struct shinstance *, int, char **);
     23int execcmd(struct shinstance *, int, char **);
     24int exitcmd(struct shinstance *, int, char **);
     25int expcmd(struct shinstance *, int, char **);
     26int exportcmd(struct shinstance *, int, char **);
     27int falsecmd(struct shinstance *, int, char **);
     28int histcmd(struct shinstance *, int, char **);
     29int inputrc(struct shinstance *, int, char **);
     30int fgcmd(struct shinstance *, int, char **);
     31int getoptscmd(struct shinstance *, int, char **);
     32int hashcmd(struct shinstance *, int, char **);
     33int jobidcmd(struct shinstance *, int, char **);
     34int jobscmd(struct shinstance *, int, char **);
     35int localcmd(struct shinstance *, int, char **);
    3636#ifndef SMALL
    37 int printfcmd(int, char **);
     37int printfcmd(struct shinstance *, int, char **);
    3838#endif
    39 int pwdcmd(int, char **);
    40 int readcmd(int, char **);
    41 int returncmd(int, char **);
    42 int setcmd(int, char **);
    43 int setvarcmd(int, char **);
    44 int shiftcmd(int, char **);
    45 int timescmd(int, char **);
    46 int trapcmd(int, char **);
    47 int truecmd(int, char **);
    48 int typecmd(int, char **);
    49 int umaskcmd(int, char **);
    50 int unaliascmd(int, char **);
    51 int unsetcmd(int, char **);
    52 int waitcmd(int, char **);
    53 int aliascmd(int, char **);
    54 int ulimitcmd(int, char **);
    55 int testcmd(int, char **);
    56 int killcmd(int, char **);
    57 int wordexpcmd(int, char **);
     39int pwdcmd(struct shinstance *, int, char **);
     40int readcmd(struct shinstance *, int, char **);
     41int returncmd(struct shinstance *, int, char **);
     42int setcmd(struct shinstance *, int, char **);
     43int setvarcmd(struct shinstance *, int, char **);
     44int shiftcmd(struct shinstance *, int, char **);
     45int timescmd(struct shinstance *, int, char **);
     46int trapcmd(struct shinstance *, int, char **);
     47int truecmd(struct shinstance *, int, char **);
     48int typecmd(struct shinstance *, int, char **);
     49int umaskcmd(struct shinstance *, int, char **);
     50int unaliascmd(struct shinstance *, int, char **);
     51int unsetcmd(struct shinstance *, int, char **);
     52int waitcmd(struct shinstance *, int, char **);
     53int aliascmd(struct shinstance *, int, char **);
     54int ulimitcmd(struct shinstance *, int, char **);
     55int testcmd(struct shinstance *, int, char **);
     56int killcmd(struct shinstance *, int, char **);
     57int wordexpcmd(struct shinstance *, int, char **);

  • trunk/src/ash-messup/main.c

    r883 r884  
    342342
    343343        INTOFF;
    344         if ((fd = open(name, O_RDONLY)) >= 0)
     344        if ((fd = shfile_open(&psh->fdtab, name, O_RDONLY)) >= 0)
    345345                setinputfd(psh, fd, 1);
    346346        else
    … …  
    371371
    372372        while ((fullname = padvance(psh, &path, basename)) != NULL) {
    373                 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
     373                if ((shfile_stat(&psh->fdtab, fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
    374374                        /*
    375375                         * Don't bother freeing here, since it will

  • trunk/src/ash-messup/memalloc.h

    r879 r884  
    7373#define STTOPC(p)       p[-1]
    7474#define STADJUST(amount, p)     (p += (amount), psh->sstrnleft -= (amount))
    75 #define grabstackstr(p) stalloc(stackblocksize() - psh->sstrnleft)
     75#define grabstackstr(p) stalloc(psh, stackblocksize() - psh->sstrnleft)
    7676
    7777#define ckfree(p)       free((pointer)(p))

  • trunk/src/ash-messup/options.h

    r880 r884  
    130130void optschanged(struct shinstance *);
    131131void setparam(struct shinstance *, char **);
    132 void freeparam(struct shinstance *, volatile struct shparam *);
     132void freeparam(volatile struct shparam *);
    133133int shiftcmd(struct shinstance *, int, char **);
    134134int setcmd(struct shinstance *, int, char **);

  • trunk/src/ash-messup/parser.h

    r879 r884  
    7979union node *parsecmd(struct shinstance *, int);
    8080void fixredir(struct shinstance *, union node *, const char *, int);
    81 int goodname(struct shinstance *, char *);
     81int goodname(char *);
    8282const char *getprompt(struct shinstance *, void *);

  • trunk/src/ash-messup/shfile.h

    r883 r884  
    5353
    5454int shfile_open(shfdtab *, const char *, unsigned);
     55int shfile_pipe(shfdtab *, int [2]);
    5556int shfile_close(shfdtab *, unsigned);
     57int shfile_fcntl(shfdtab *, int fd, int cmd, int arg);
     58#ifdef _MSC_VER
     59# define F_DUPFD    0
     60# define F_GETFD    1
     61# define F_SETFD    2
     62# define F_GETFL    3
     63# define F_SETFL    4
     64# define FD_CLOEXEC 1
     65#else
     66# include <sys/fcntl.h>
     67#endif
    5668
    5769int shfile_stat(shfdtab *, const char *, struct stat *);

  • trunk/src/ash-messup/shinstance.h

    r883 r884  
    138138    int                 back_exitstatus;/**< exit status of backquoted command */
    139139    struct strlist     *cmdenviron;     /**< environment for builtin command */
    140     int                 funcnest;
    141     int                 evalskip;
     140    int                 funcnest;       /**< depth of function calls */
     141    int                 evalskip;       /**< set if we are skipping commands */
     142    int                 skipcount;      /**< number of levels to skip */
     143    int                 loopnest;       /**< current loop nesting level */
    142144
    143145    /* builtins.h */
    … …  
    156158    char                errmsg_buf[16]; /**< static in errmsg. (bss) */
    157159
     160    /* eval.c */
     161    int                 vforked;
    158162} shinstance;
    159163
    … …  
    165169#include <signal.h>
    166170#ifdef _MSC_VER
    167 typedef uint32_t sh_sigset_t;
     171    typedef uint32_t sh_sigset_t;
    168172#else
    169 typedef sigset_t sh_sigset_t;
     173    typedef sigset_t sh_sigset_t;
    170174#endif
    171175
    … …  
    176180int sh_sigprocmask(shinstance *, int op, sh_sigset_t const *new, sh_sigset_t *old);
    177181
    178 #endif
     182/* times */
     183#include <time.h>
     184#ifdef _MSC_VER
     185    typedef struct sh_tms
     186    {
     187        clock_t tms_utime;
     188        clock_t tms_stime;
     189        clock_t tms_cutime;
     190        clock_t tms_cstime;
     191    } sh_tms;
     192#else
     193#   include <times.h>
     194    typedef struct tms sh_tms;
     195#endif
     196clock_t sh_times(sh_tms *);
     197int sh_sysconf_clk_tck(void);
     198
     199/* wait */
     200#ifdef _MSC_VER
     201#   include <process.h>
     202#   define WNOHANG         1       /* Don't hang in wait. */
     203#   define WUNTRACED       2       /* Tell about stopped, untraced children. */
     204#   define WCONTINUED      4       /* Report a job control continued process. */
     205#   define _W_INT(w)       (*(int *)&(w))  /* Convert union wait to int. */
     206#   define WCOREFLAG       0200
     207#   define _WSTATUS(x)     (_W_INT(x) & 0177)
     208#   define _WSTOPPED       0177            /* _WSTATUS if process is stopped */
     209#   define WIFSTOPPED(x)   (_WSTATUS(x) == _WSTOPPED)
     210#   define WSTOPSIG(x)     (_W_INT(x) >> 8)
     211#   define WIFSIGNALED(x)  (_WSTATUS(x) != 0 && !WIFSTOPPED(x) && !WIFCONTINUED(x)) /* bird: made GLIBC tests happy. */
     212#   define WTERMSIG(x)     (_WSTATUS(x))
     213#   define WIFEXITED(x)    (_WSTATUS(x) == 0)
     214#   define WEXITSTATUS(x)  (_W_INT(x) >> 8)
     215#   define WIFCONTINUED(x) (x == 0x13)     /* 0x13 == SIGCONT */
     216#   define WCOREDUMP(x)    (_W_INT(x) & WCOREFLAG)
     217#   define W_EXITCODE(ret, sig)    ((ret) << 8 | (sig))
     218#   define W_STOPCODE(sig)         ((sig) << 8 | _WSTOPPED)
     219#else
     220#   include <sys/wait.h>
     221#endif
     222pid_t sh_waitpid(shinstance *, pid_t, int *, int);
     223void sh__exit(shinstance *, int);
     224
     225#endif

  • trunk/src/ash-messup/var.h

    r880 r884  
    3434 *      @(#)var.h       8.2 (Berkeley) 5/4/95
    3535 */
     36
     37#ifndef ___var_h___
     38#define ___var_h___
    3639
    3740/*
    … …  
    143146int setvarsafe(struct shinstance *, const char *, const char *, int);
    144147void print_quoted(struct shinstance *, const char *);
     148
     149#endif
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette