VirtualBox

Changeset 1203 in kBuild


Ignore:
Timestamp:
Oct 7, 2007 1:39:01 AM (17 years ago)
Author:
bird
Message:

converted a few more files.

Location:
trunk/src/kash
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/kash/Makefile.kmk

    r1201 r1203  
    4545        output.c \
    4646        input.c \
    47         \
    4847        exec.c \
    4948        expand.c \
     49        \
    5050        jobs.c \
    5151        miscbltin.c \
  • trunk/src/kash/bltin/bltin.h

    r1202 r1203  
    7272#define exit sh_exit
    7373#define setprogname(s)
    74 #define getprogname() commandname
     74#define getprogname() psh->commandname
    7575#define setlocate(l,s) 0
    7676
  • trunk/src/kash/eval.c

    r1199 r1203  
    881881                                                sh__exit(psh, 0);
    882882                                        } else {
    883                                                 sh__exit(psh, exerrno);
     883                                                sh__exit(psh, psh->exerrno);
    884884                                        }
    885885                                }
  • trunk/src/kash/exec.c

    r1202 r1203  
    8686#endif
    8787
    88 
    89 #define CMDTABLESIZE 31         /* should be prime */
    90 #define ARB 1                   /* actual size determined at run time */
    91 
    92 
    93 
    94 struct tblentry {
    95         struct tblentry *next;  /* next entry in hash chain */
    96         union param param;      /* definition of builtin function */
    97         short cmdtype;          /* index identifying command */
    98         char rehash;            /* if set, cd done since entry created */
    99         char cmdname[ARB];      /* name of command */
    100 };
    101 
    102 
    103 STATIC struct tblentry *cmdtable[CMDTABLESIZE];
    104 STATIC int builtinloc = -1;             /* index in path of %builtin, or -1 */
    105 int exerrno = 0;                        /* Last exec error */
    106 
    107 
    108 STATIC void tryexec(char *, char **, char **, int, int);
    109 STATIC void execinterp(char **, char **);
    110 STATIC void printentry(struct tblentry *, int);
    111 STATIC void clearcmdentry(int);
    112 STATIC struct tblentry *cmdlookup(const char *, int);
    113 STATIC void delete_cmd_entry(void);
     88#include "shinstance.h"
     89
     90//#define CMDTABLESIZE 31               /* should be prime */
     91//#define ARB 1                 /* actual size determined at run time */
     92//
     93//
     94//
     95//struct tblentry {
     96//      struct tblentry *next;  /* next entry in hash chain */
     97//      union param param;      /* definition of builtin function */
     98//      short cmdtype;          /* index identifying command */
     99//      char rehash;            /* if set, cd done since entry created */
     100//      char cmdname[ARB];      /* name of command */
     101//};
     102//
     103//
     104//STATIC struct tblentry *cmdtable[CMDTABLESIZE];
     105//STATIC int builtinloc = -1;           /* index in path of %builtin, or -1 */
     106//int exerrno = 0;                      /* Last exec error */
     107
     108
     109STATIC void tryexec(shinstance *, char *, char **, char **, int, int);
     110STATIC void execinterp(shinstance *, char **, char **);
     111STATIC void printentry(shinstance *, struct tblentry *, int);
     112STATIC void clearcmdentry(shinstance *, int);
     113STATIC struct tblentry *cmdlookup(shinstance *, const char *, int);
     114STATIC void delete_cmd_entry(shinstance *);
    114115#ifdef PC_EXE_EXTS
    115 STATIC int stat_pc_exec_exts(char *fullname, struct stat *st, int has_ext);
     116STATIC int stat_pc_exec_exts(shinstance *, char *fullname, struct stat *st, int has_ext);
    116117#endif
    117118
     
    125126
    126127void
    127 shellexec(char **argv, char **envp, const char *path, int idx, int vforked)
     128shellexec(shinstance *psh, char **argv, char **envp, const char *path, int idx, int vforked)
    128129{
    129130        char *cmdname;
    130131        int e;
    131132#ifdef PC_EXE_EXTS
    132         int has_ext = strlen(argv[0]) - 4;
     133        int has_ext = (int)strlen(argv[0]) - 4;
    133134        has_ext = has_ext > 0
    134135            && argv[0][has_ext] == '.'
     
    148149                cmdname = stalloc(psh, strlen(argv[0]) + 5);
    149150                strcpy(cmdname, argv[0]);
    150                 tryexec(cmdname, argv, envp, vforked, has_ext);
     151                tryexec(psh, cmdname, argv, envp, vforked, has_ext);
    151152                TRACE((psh, "shellexec: cmdname=%s\n", cmdname));
    152153                stunalloc(psh, cmdname);
     
    155156                e = ENOENT;
    156157                while ((cmdname = padvance(psh, &path, argv[0])) != NULL) {
    157                         if (--idx < 0 && pathopt == NULL) {
    158                                 tryexec(cmdname, argv, envp, vforked, has_ext);
     158                        if (--idx < 0 && psh->pathopt == NULL) {
     159                                tryexec(psh, cmdname, argv, envp, vforked, has_ext);
    159160                                if (errno != ENOENT && errno != ENOTDIR)
    160161                                        e = errno;
     
    167168        switch (e) {
    168169        case EACCES:
    169                 exerrno = 126;
     170                psh->exerrno = 126;
    170171                break;
    171172        case ENOENT:
    172                 exerrno = 127;
     173                psh->exerrno = 127;
    173174                break;
    174175        default:
    175                 exerrno = 2;
     176                psh->exerrno = 2;
    176177                break;
    177178        }
    178179        TRACE((psh, "shellexec failed for '%s', errno %d, vforked %d, suppressint %d\n",
    179                 argv[0], e, vforked, suppressint ));
     180                argv[0], e, vforked, psh->suppressint ));
    180181        exerror(psh, EXEXEC, "%s: %s", argv[0], errmsg(psh, e, E_EXEC));
    181182        /* NOTREACHED */
     
    184185
    185186STATIC void
    186 tryexec(char *cmd, char **argv, char **envp, int vforked, int has_ext)
     187tryexec(shinstance *psh, char *cmd, char **argv, char **envp, int vforked, int has_ext)
    187188{
    188189        int e;
     
    196197        struct stat st;
    197198        if (!has_ext)
    198             stat_pc_exec_exts(cmd, &st, 0);
     199            stat_pc_exec_exts(psh, cmd, &st, 0);
    199200#endif
    200201#if defined __INNOTEK_LIBC__ && defined EXEC_HASH_BANG_SCRIPT
     
    204205#ifdef SYSV
    205206        do {
    206                 execve(cmd, argv, envp);
     207                sh_execve(psh, cmd, argv, envp);
    207208        } while (errno == EINTR);
    208209#else
    209         execve(cmd, argv, envp);
     210        sh_execve(psh, cmd, argv, envp);
    210211#endif
    211212        e = errno;
     
    220221                initshellproc(psh);
    221222                setinputfile(psh, cmd, 0);
    222                 commandname = arg0 = savestr(argv[0]);
     223                psh->commandname = psh->arg0 = savestr(argv[0]);
    223224#ifdef EXEC_HASH_BANG_SCRIPT
    224225                pgetc(psh); pungetc(psh);               /* fill up input buffer */
    225                 p = parsenextc;
    226                 if (parsenleft > 2 && p[0] == '#' && p[1] == '!') {
     226                p = psh->parsenextc;
     227                if (psh->parsenleft > 2 && p[0] == '#' && p[1] == '!') {
    227228                        argv[0] = cmd;
    228                         execinterp(argv, envp);
     229                        execinterp(psh, argv, envp);
    229230                }
    230231#endif
     
    250251
    251252STATIC void
    252 execinterp(char **argv, char **envp)
     253execinterp(shinstance *psh, char **argv, char **envp)
    253254{
    254255        int n;
     
    263264        char **new;
    264265
    265         n = parsenleft - 2;
    266         inp = parsenextc + 2;
     266        n = psh->parsenleft - 2;
     267        inp = psh->parsenextc + 2;
    267268        ap = newargs;
    268269        for (;;) {
     
    310311        while (*ap2++ = *ap++);
    311312        TRACE((psh, "hash bang '%s'\n", new[0]));
    312         shellexec(psh, new, envp, pathval(), 0, 0);
     313        shellexec(psh, new, envp, pathval(psh), 0, 0);
    313314        /* NOTREACHED */
    314315}
     
    323324 * the possible path expansions in sequence.  If an option (indicated by
    324325 * a percent sign) appears in the path entry then the global variable
    325  * pathopt will be set to point to it; otherwise pathopt will be set to
     326 * psh->pathopt will be set to point to it; otherwise psh->pathopt will be set to
    326327 * NULL.
    327328 */
    328329
    329 const char *pathopt;
     330//const char *pathopt;
    330331
    331332char *
    332 padvance(const char **path, const char *name)
     333padvance(shinstance *psh, const char **path, const char *name)
    333334{
    334335        const char *p;
     
    345346        for (p = start ; *p && *p != ':' && *p != '%' ; p++);
    346347#endif
    347         len = p - start + strlen(name) + 2;     /* "2" is for '/' and '\0' */
     348        len = (int)(p - start + strlen(name) + 2);      /* "2" is for '/' and '\0' */
    348349#ifdef PC_EXE_EXTS
    349350        len += 4; /* "4" is for .exe/.com/.cmd/.bat/.btm */
     
    358359        }
    359360        strcpy(q, name);
    360         pathopt = NULL;
     361        psh->pathopt = NULL;
    361362        if (*p == '%') {
    362                 pathopt = ++p;
     363                psh->pathopt = ++p;
    363364#ifdef PC_PATH_SEP
    364365                while (*p && *p != ';')  p++;
     
    380381
    381382#ifdef PC_EXE_EXTS
    382 STATIC int stat_pc_exec_exts(char *fullname, struct stat *st, int has_ext)
     383STATIC int stat_pc_exec_exts(shinstance *psh, char *fullname, struct stat *st, int has_ext)
    383384{
    384385    /* skip the SYSV crap */
    385     if (stat(fullname, st) >= 0)
     386    if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    386387        return 0;
    387388    if (!has_ext && errno == ENOENT)
     
    389390        char *psz = strchr(fullname, '\0');
    390391        memcpy(psz, ".exe", 5);
    391         if (stat(fullname, st) >= 0)
     392        if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    392393            return 0;
    393394        if (errno != ENOENT && errno != ENOTDIR)
     
    395396
    396397        memcpy(psz, ".cmd", 5);
    397         if (stat(fullname, st) >= 0)
     398        if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    398399            return 0;
    399400        if (errno != ENOENT && errno != ENOTDIR)
     
    401402
    402403        memcpy(psz, ".bat", 5);
    403         if (stat(fullname, st) >= 0)
     404        if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    404405            return 0;
    405406        if (errno != ENOENT && errno != ENOTDIR)
     
    407408
    408409        memcpy(psz, ".com", 5);
    409         if (stat(fullname, st) >= 0)
     410        if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    410411            return 0;
    411412        if (errno != ENOENT && errno != ENOTDIR)
     
    413414
    414415        memcpy(psz, ".btm", 5);
    415         if (stat(fullname, st) >= 0)
     416        if (shfile_stat(&psh->fdtab, fullname, st) >= 0)
    416417            return 0;
    417418        *psz = '\0';
     
    427428
    428429int
    429 hashcmd(int argc, char **argv)
     430hashcmd(shinstance *psh, int argc, char **argv)
    430431{
    431432        struct tblentry **pp;
     
    439440        while ((c = nextopt(psh, "rv")) != '\0') {
    440441                if (c == 'r') {
    441                         clearcmdentry(0);
     442                        clearcmdentry(psh, 0);
    442443                } else if (c == 'v') {
    443444                        verbose++;
    444445                }
    445446        }
    446         if (*argptr == NULL) {
    447                 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
     447        if (*psh->argptr == NULL) {
     448                for (pp = psh->cmdtable ; pp < &psh->cmdtable[CMDTABLESIZE] ; pp++) {
    448449                        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    449450                                if (verbose || cmdp->cmdtype == CMDNORMAL)
    450                                         printentry(cmdp, verbose);
     451                                        printentry(psh, cmdp, verbose);
    451452                        }
    452453                }
    453454                return 0;
    454455        }
    455         while ((name = *argptr) != NULL) {
    456                 if ((cmdp = cmdlookup(name, 0)) != NULL
     456        while ((name = *psh->argptr) != NULL) {
     457                if ((cmdp = cmdlookup(psh, name, 0)) != NULL
    457458                 && (cmdp->cmdtype == CMDNORMAL
    458                      || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
    459                         delete_cmd_entry();
    460                 find_command(psh, name, &entry, DO_ERR, pathval());
     459                     || (cmdp->cmdtype == CMDBUILTIN && psh->builtinloc >= 0)))
     460                        delete_cmd_entry(psh);
     461                find_command(psh, name, &entry, DO_ERR, pathval(psh));
    461462                if (verbose) {
    462463                        if (entry.cmdtype != CMDUNKNOWN) {      /* if no error msg */
    463                                 cmdp = cmdlookup(name, 0);
    464                                 printentry(cmdp, verbose);
     464                                cmdp = cmdlookup(psh, name, 0);
     465                                printentry(psh, cmdp, verbose);
    465466                        }
    466467                        output_flushall(psh);
    467468                }
    468                 argptr++;
     469                psh->argptr++;
    469470        }
    470471        return 0;
     
    473474
    474475STATIC void
    475 printentry(struct tblentry *cmdp, int verbose)
     476printentry(shinstance *psh, struct tblentry *cmdp, int verbose)
    476477{
    477478        int idx;
     
    482483        case CMDNORMAL:
    483484                idx = cmdp->param.index;
    484                 path = pathval();
     485                path = pathval(psh);
    485486                do {
    486487                        name = padvance(psh, &path, cmdp->cmdname);
     
    523524
    524525void
    525 find_command(char *name, struct cmdentry *entry, int act, const char *path)
     526find_command(shinstance *psh, char *name, struct cmdentry *entry, int act, const char *path)
    526527{
    527528        struct tblentry *cmdp, loc_cmd;
     
    531532        struct stat statb;
    532533        int e;
    533         int (*bltin)(int,char **);
     534        int (*bltin)(shinstance*,int,char **);
    534535
    535536#ifdef PC_EXE_EXTS
    536         int has_ext = strlen(name) - 4;
     537        int has_ext = (int)(strlen(name) - 4);
    537538        has_ext = has_ext > 0
    538539            && name[has_ext] == '.'
     
    550551        if (strchr(name, '/') != NULL) {
    551552                if (act & DO_ABS) {
    552                         while (stat(name, &statb) < 0) {
     553                        while (shfile_stat(&psh->fdtab, name, &statb) < 0) {
    553554#ifdef SYSV
    554555                                if (errno == EINTR)
     
    570571        }
    571572
    572         if (path != pathval())
     573        if (path != pathval(psh))
    573574                act |= DO_ALTPATH;
    574575
     
    577578
    578579        /* If name is in the table, check answer will be ok */
    579         if ((cmdp = cmdlookup(name, 0)) != NULL) {
     580        if ((cmdp = cmdlookup(psh, name, 0)) != NULL) {
    580581                do {
    581582                        switch (cmdp->cmdtype) {
     
    593594                                break;
    594595                        case CMDBUILTIN:
    595                                 if ((act & DO_ALTBLTIN) || builtinloc >= 0) {
     596                                if ((act & DO_ALTBLTIN) || psh->builtinloc >= 0) {
    596597                                        cmdp = NULL;
    597598                                        continue;
     
    606607
    607608        /* If %builtin not in path, check for builtin next */
    608         if ((act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : builtinloc < 0) &&
     609        if ((act & DO_ALTPATH ? !(act & DO_ALTBLTIN) : psh->builtinloc < 0) &&
    609610            (bltin = find_builtin(psh, name)) != 0)
    610611                goto builtin_success;
     
    614615        if (cmdp) {             /* doing a rehash */
    615616                if (cmdp->cmdtype == CMDBUILTIN)
    616                         prev = builtinloc;
     617                        prev = psh->builtinloc;
    617618                else
    618619                        prev = cmdp->param.index;
     
    625626                stunalloc(psh, fullname);
    626627                idx++;
    627                 if (pathopt) {
    628                         if (prefix("builtin", pathopt)) {
     628                if (psh->pathopt) {
     629                        if (prefix("builtin", psh->pathopt)) {
    629630                                if ((bltin = find_builtin(psh, name)) == 0)
    630631                                        goto loop;
    631632                                goto builtin_success;
    632                         } else if (prefix("func", pathopt)) {
     633                        } else if (prefix("func", psh->pathopt)) {
    633634                                /* handled below */
    634635                        } else {
     
    645646                }
    646647#ifdef PC_EXE_EXTS
    647                 while (stat_pc_exec_exts(fullname, &statb, has_ext) < 0) {
     648                while (stat_pc_exec_exts(psh, fullname, &statb, has_ext) < 0) {
    648649#else
    649                 while (stat(fullname, &statb) < 0) {
     650                while (shfile_stat(&psh->fdtab, fullname, &statb) < 0) {
    650651#endif
    651652#ifdef SYSV
     
    661662                if (!S_ISREG(statb.st_mode))
    662663                        goto loop;
    663                 if (pathopt) {          /* this is a %func directory */
     664                if (psh->pathopt) {             /* this is a %func directory */
    664665                        if (act & DO_NOFUNC)
    665666                                goto loop;
    666667                        stalloc(psh, strlen(fullname) + 1);
    667668                        readcmdfile(psh, fullname);
    668                         if ((cmdp = cmdlookup(name, 0)) == NULL ||
     669                        if ((cmdp = cmdlookup(psh, name, 0)) == NULL ||
    669670                            cmdp->cmdtype != CMDFUNCTION)
    670671                                error(psh, "%s not defined in %s", name, fullname);
     
    692693                        cmdp = &loc_cmd;
    693694                } else
    694                         cmdp = cmdlookup(name, 1);
     695                        cmdp = cmdlookup(psh, name, 1);
    695696                cmdp->cmdtype = CMDNORMAL;
    696697                cmdp->param.index = idx;
     
    701702        /* We failed.  If there was an entry for this command, delete it */
    702703        if (cmdp)
    703                 delete_cmd_entry();
     704                delete_cmd_entry(psh);
    704705        if (act & DO_ERR)
    705706                outfmt(psh->out2, "%s: %s\n", name, errmsg(psh, e, E_EXEC));
     
    712713                cmdp = &loc_cmd;
    713714        else
    714                 cmdp = cmdlookup(name, 1);
     715                cmdp = cmdlookup(psh, name, 1);
    715716        if (cmdp->cmdtype == CMDFUNCTION)
    716717                /* DO_NOFUNC must have been set */
     
    732733
    733734int
    734 (*find_builtin(name))(int, char **)
    735         char *name;
     735(*find_builtin(shinstance *psh, char *name))(shinstance *psh, int, char **)
    736736{
    737737        const struct builtincmd *bp;
     
    745745
    746746int
    747 (*find_splbltin(name))(int, char **)
    748         char *name;
     747(*find_splbltin(shinstance *psh, char *name))(shinstance *psh, int, char **)
    749748{
    750749        const struct builtincmd *bp;
     
    765764
    766765void
    767 hash_special_builtins(void)
     766hash_special_builtins(shinstance *psh)
    768767{
    769768        const struct builtincmd *bp;
     
    771770
    772771        for (bp = splbltincmd ; bp->name ; bp++) {
    773                 cmdp = cmdlookup(bp->name, 1);
     772                cmdp = cmdlookup(psh, bp->name, 1);
    774773                cmdp->cmdtype = CMDSPLBLTIN;
    775774                cmdp->param.bltin = bp->builtin;
     
    785784
    786785void
    787 hashcd(void)
     786hashcd(shinstance *psh)
    788787{
    789788        struct tblentry **pp;
    790789        struct tblentry *cmdp;
    791790
    792         for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
     791        for (pp = psh->cmdtable ; pp < &psh->cmdtable[CMDTABLESIZE] ; pp++) {
    793792                for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    794793                        if (cmdp->cmdtype == CMDNORMAL
    795                          || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
     794                         || (cmdp->cmdtype == CMDBUILTIN && psh->builtinloc >= 0))
    796795                                cmdp->rehash = 1;
    797796                }
     
    804803 * Fix command hash table when PATH changed.
    805804 * Called before PATH is changed.  The argument is the new value of PATH;
    806  * pathval() still returns the old value at this point.
     805 * pathval(psh) still returns the old value at this point.
    807806 * Called with interrupts off.
    808807 */
    809808
    810809void
    811 changepath(const char *newval)
     810changepath(shinstance *psh, const char *newval)
    812811{
    813812        const char *old, *new;
     
    816815        int bltin;
    817816
    818         old = pathval();
     817        old = pathval(psh);
    819818        new = newval;
    820819        firstchange = 9999;     /* assume no change */
     
    847846                new++, old++;
    848847        }
    849         if (builtinloc < 0 && bltin >= 0)
    850                 builtinloc = bltin;             /* zap builtins */
    851         if (builtinloc >= 0 && bltin < 0)
     848        if (psh->builtinloc < 0 && bltin >= 0)
     849                psh->builtinloc = bltin;                /* zap builtins */
     850        if (psh->builtinloc >= 0 && bltin < 0)
    852851                firstchange = 0;
    853         clearcmdentry(firstchange);
    854         builtinloc = bltin;
     852        clearcmdentry(psh, firstchange);
     853        psh->builtinloc = bltin;
    855854}
    856855
     
    862861
    863862STATIC void
    864 clearcmdentry(int firstchange)
     863clearcmdentry(shinstance *psh, int firstchange)
    865864{
    866865        struct tblentry **tblp;
     
    869868
    870869        INTOFF;
    871         for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
     870        for (tblp = psh->cmdtable ; tblp < &psh->cmdtable[CMDTABLESIZE] ; tblp++) {
    872871                pp = tblp;
    873872                while ((cmdp = *pp) != NULL) {
     
    875874                             cmdp->param.index >= firstchange)
    876875                         || (cmdp->cmdtype == CMDBUILTIN &&
    877                              builtinloc >= firstchange)) {
     876                             psh->builtinloc >= firstchange)) {
    878877                                *pp = cmdp->next;
    879878                                ckfree(cmdp);
     
    905904
    906905void
    907 deletefuncs(void)
     906deletefuncs(shinstance *psh)
    908907{
    909908        struct tblentry **tblp;
     
    912911
    913912        INTOFF;
    914         for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
     913        for (tblp = psh->cmdtable ; tblp < &psh->cmdtable[CMDTABLESIZE] ; tblp++) {
    915914                pp = tblp;
    916915                while ((cmdp = *pp) != NULL) {
     
    941940
    942941STATIC struct tblentry *
    943 cmdlookup(const char *name, int add)
     942cmdlookup(shinstance *psh, const char *name, int add)
    944943{
    945944        int hashval;
     
    953952                hashval += *p++;
    954953        hashval &= 0x7FFF;
    955         pp = &cmdtable[hashval % CMDTABLESIZE];
     954        pp = &psh->cmdtable[hashval % CMDTABLESIZE];
    956955        for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
    957956                if (equal(cmdp->cmdname, name))
     
    978977
    979978STATIC void
    980 delete_cmd_entry(void)
     979delete_cmd_entry(shinstance *psh)
    981980{
    982981        struct tblentry *cmdp;
     
    993992#ifdef notdef
    994993void
    995 getcmdentry(char *name, struct cmdentry *entry)
    996 {
    997         struct tblentry *cmdp = cmdlookup(name, 0);
     994getcmdentry(shinstance *psh, char *name, struct cmdentry *entry)
     995{
     996        struct tblentry *cmdp = cmdlookup(psh, name, 0);
    998997
    999998        if (cmdp) {
     
    10141013
    10151014STATIC void
    1016 addcmdentry(char *name, struct cmdentry *entry)
     1015addcmdentry(shinstance *psh, char *name, struct cmdentry *entry)
    10171016{
    10181017        struct tblentry *cmdp;
    10191018
    10201019        INTOFF;
    1021         cmdp = cmdlookup(name, 1);
     1020        cmdp = cmdlookup(psh, name, 1);
    10221021        if (cmdp->cmdtype != CMDSPLBLTIN) {
    10231022                if (cmdp->cmdtype == CMDFUNCTION) {
     
    10361035
    10371036void
    1038 defun(char *name, union node *func)
     1037defun(shinstance *psh,char *name, union node *func)
    10391038{
    10401039        struct cmdentry entry;
     
    10531052
    10541053int
    1055 unsetfunc(char *name)
     1054unsetfunc(shinstance *psh, char *name)
    10561055{
    10571056        struct tblentry *cmdp;
    10581057
    1059         if ((cmdp = cmdlookup(name, 0)) != NULL &&
     1058        if ((cmdp = cmdlookup(psh, name, 0)) != NULL &&
    10601059            cmdp->cmdtype == CMDFUNCTION) {
    10611060                freefunc(cmdp->param.func);
    1062                 delete_cmd_entry();
     1061                delete_cmd_entry(psh);
    10631062                return (0);
    10641063        }
     
    10721071
    10731072int
    1074 typecmd(int argc, char **argv)
     1073typecmd(shinstance *psh, int argc, char **argv)
    10751074{
    10761075        struct cmdentry entry;
     
    10961095                error(psh, "cannot specify -p with -v or -V");
    10971096
    1098         while ((arg = *argptr++)) {
     1097        while ((arg = *psh->argptr++)) {
    10991098                if (!v_flag)
    11001099                        out1str(psh, arg);
     
    11211120
    11221121                /* Then check if it is a tracked alias */
    1123                 if ((cmdp = cmdlookup(arg, 0)) != NULL) {
     1122                if ((cmdp = cmdlookup(psh, arg, 0)) != NULL) {
    11241123                        entry.cmdtype = cmdp->cmdtype;
    11251124                        entry.u = cmdp->param;
    11261125                } else {
    11271126                        /* Finally use brute force */
    1128                         find_command(psh, arg, &entry, DO_ABS, pathval());
     1127                        find_command(psh, arg, &entry, DO_ABS, pathval(psh));
    11291128                }
    11301129
     
    11321131                case CMDNORMAL: {
    11331132                        if (strchr(arg, '/') == NULL) {
    1134                                 const char *path = pathval();
     1133                                const char *path = pathval(psh);
    11351134                                char *name;
    11361135                                int j = entry.u.index;
  • trunk/src/kash/exec.h

    r884 r1203  
    3434 *      @(#)exec.h      8.3 (Berkeley) 6/8/95
    3535 */
     36
     37#ifndef ___exec_h
     38#define ___exec_h
    3639
    3740/* values of cmdtype */
     
    7881int typecmd(struct shinstance *, int, char **);
    7982void hash_special_builtins(struct shinstance *);
     83
     84#endif
  • trunk/src/kash/expand.c

    r1202 r1203  
    7878#include "mystring.h"
    7979#include "show.h"
    80 
    81 /*
    82  * Structure specifying which parts of the string should be searched
    83  * for IFS characters.
    84  */
    85 
    86 struct ifsregion {
    87         struct ifsregion *next; /* next region in list */
    88         int begoff;             /* offset of start of region */
    89         int endoff;             /* offset of end of region */
    90         int inquotes;           /* search for nul bytes only */
    91 };
    92 
    93 
    94 char *expdest;                  /* output of current string */
    95 struct nodelist *argbackq;      /* list of back quote expressions */
    96 struct ifsregion ifsfirst;      /* first struct in list of ifs regions */
    97 struct ifsregion *ifslastp;     /* last struct in list */
    98 struct arglist exparg;          /* holds expanded arg list */
    99 
    100 STATIC void argstr(char *, int);
    101 STATIC char *exptilde(char *, int);
    102 STATIC void expbackq(union node *, int, int);
    103 STATIC int subevalvar(char *, char *, int, int, int, int);
    104 STATIC char *evalvar(char *, int);
    105 STATIC int varisset(char *, int);
    106 STATIC void varvalue(char *, int, int, int);
    107 STATIC void recordregion(int, int, int);
    108 STATIC void removerecordregions(int);
    109 STATIC void ifsbreakup(char *, struct arglist *);
    110 STATIC void ifsfree(void);
    111 STATIC void expandmeta(struct strlist *, int);
    112 STATIC void expmeta(char *, char *);
    113 STATIC void addfname(char *);
     80#include "shinstance.h"
     81
     82///*
     83// * Structure specifying which parts of the string should be searched
     84// * for IFS characters.
     85// */
     86//
     87//struct ifsregion {
     88//      struct ifsregion *next; /* next region in list */
     89//      int begoff;             /* offset of start of region */
     90//      int endoff;             /* offset of end of region */
     91//      int inquotes;           /* search for nul bytes only */
     92//};
     93//
     94//
     95//char *expdest;                        /* output of current string */
     96//struct nodelist *argbackq;    /* list of back quote expressions */
     97//struct ifsregion ifsfirst;    /* first struct in list of ifs regions */
     98//struct ifsregion *ifslastp;   /* last struct in list */
     99//struct arglist exparg;                /* holds expanded arg list */
     100
     101STATIC void argstr(shinstance *, char *, int);
     102STATIC char *exptilde(shinstance *, char *, int);
     103STATIC void expbackq(shinstance *, union node *, int, int);
     104STATIC int subevalvar(shinstance *, char *, char *, int, int, int, int);
     105STATIC char *evalvar(shinstance *, char *, int);
     106STATIC int varisset(shinstance *, char *, int);
     107STATIC void varvalue(shinstance *, char *, int, int, int);
     108STATIC void recordregion(shinstance *, int, int, int);
     109STATIC void removerecordregions(shinstance *, int);
     110STATIC void ifsbreakup(shinstance *, char *, struct arglist *);
     111STATIC void ifsfree(shinstance *);
     112STATIC void expandmeta(shinstance *, struct strlist *, int);
     113STATIC void expmeta(shinstance *, char *, char *);
     114STATIC void addfname(shinstance *, char *);
    114115STATIC struct strlist *expsort(struct strlist *);
    115116STATIC struct strlist *msort(struct strlist *, int);
    116117STATIC int pmatch(char *, char *, int);
    117 STATIC char *cvtnum(int, char *);
     118STATIC char *cvtnum(shinstance *, int, char *);
    118119
    119120/*
     
    138139
    139140void
    140 expandarg(union node *arg, struct arglist *arglist, int flag)
     141expandarg(shinstance *psh, union node *arg, struct arglist *arglist, int flag)
    141142{
    142143        struct strlist *sp;
    143144        char *p;
    144145
    145         argbackq = arg->narg.backquote;
    146         STARTSTACKSTR(psh, expdest);
    147         ifsfirst.next = NULL;
    148         ifslastp = NULL;
    149         argstr(arg->narg.text, flag);
     146        psh->argbackq = arg->narg.backquote;
     147        STARTSTACKSTR(psh, psh->expdest);
     148        psh->ifsfirst.next = NULL;
     149        psh->ifslastp = NULL;
     150        argstr(psh, arg->narg.text, flag);
    150151        if (arglist == NULL) {
    151152                return;                 /* here document expanded */
    152153        }
    153         STPUTC(psh, '\0', expdest);
    154         p = grabstackstr(psh, expdest);
    155         exparg.lastp = &exparg.list;
     154        STPUTC(psh, '\0', psh->expdest);
     155        p = grabstackstr(psh, psh->expdest);
     156        psh->exparg.lastp = &psh->exparg.list;
    156157        /*
    157158         * TODO - EXP_REDIR
    158159         */
    159160        if (flag & EXP_FULL) {
    160                 ifsbreakup(p, &exparg);
    161                 *exparg.lastp = NULL;
    162                 exparg.lastp = &exparg.list;
    163                 expandmeta(exparg.list, flag);
     161                ifsbreakup(psh, p, &psh->exparg);
     162                *psh->exparg.lastp = NULL;
     163                psh->exparg.lastp = &psh->exparg.list;
     164                expandmeta(psh, psh->exparg.list, flag);
    164165        } else {
    165166                if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
     
    167168                sp = (struct strlist *)stalloc(psh, sizeof (struct strlist));
    168169                sp->text = p;
    169                 *exparg.lastp = sp;
    170                 exparg.lastp = &sp->next;
    171         }
    172         ifsfree();
    173         *exparg.lastp = NULL;
    174         if (exparg.list) {
    175                 *arglist->lastp = exparg.list;
    176                 arglist->lastp = exparg.lastp;
     170                *psh->exparg.lastp = sp;
     171                psh->exparg.lastp = &sp->next;
     172        }
     173        ifsfree(psh);
     174        *psh->exparg.lastp = NULL;
     175        if (psh->exparg.list) {
     176                *arglist->lastp = psh->exparg.list;
     177                arglist->lastp = psh->exparg.lastp;
    177178        }
    178179}
     
    187188
    188189STATIC void
    189 argstr(char *p, int flag)
     190argstr(shinstance *psh, char *p, int flag)
    190191{
    191192        char c;
     
    196197
    197198        if (flag & EXP_IFS_SPLIT)
    198                 ifs = ifsset() ? ifsval() : " \t\n";
     199                ifs = ifsset(psh) ? ifsval(psh) : " \t\n";
    199200
    200201        if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
    201                 p = exptilde(p, flag);
     202                p = exptilde(psh, p, flag);
    202203        for (;;) {
    203204                switch (c = *p++) {
     
    210211                                break;
    211212                        if ((flag & EXP_FULL) != 0)
    212                                 STPUTC(psh, c, expdest);
     213                                STPUTC(psh, c, psh->expdest);
    213214                        ifs_split = 0;
    214215                        break;
     
    218219                case CTLESC:
    219220                        if (quotes)
    220                                 STPUTC(psh, c, expdest);
     221                                STPUTC(psh, c, psh->expdest);
    221222                        c = *p++;
    222                         STPUTC(psh, c, expdest);
     223                        STPUTC(psh, c, psh->expdest);
    223224                        break;
    224225                case CTLVAR:
    225                         p = evalvar(p, (flag & ~EXP_IFS_SPLIT) | (flag & ifs_split));
     226                        p = evalvar(psh, p, (flag & ~EXP_IFS_SPLIT) | (flag & ifs_split));
    226227                        break;
    227228                case CTLBACKQ:
    228229                case CTLBACKQ|CTLQUOTE:
    229                         expbackq(argbackq->n, c & CTLQUOTE, flag);
    230                         argbackq = argbackq->next;
     230                        expbackq(psh, psh->argbackq->n, c & CTLQUOTE, flag);
     231                        psh->argbackq = psh->argbackq->next;
    231232                        break;
    232233                case CTLENDARI:
     
    239240                         * assignments (after the first '=' and after ':'s).
    240241                         */
    241                         STPUTC(psh, c, expdest);
     242                        STPUTC(psh, c, psh->expdest);
    242243                        if (flag & EXP_VARTILDE && *p == '~') {
    243244                                if (c == '=') {
     
    247248                                                break;
    248249                                }
    249                                 p = exptilde(p, flag);
     250                                p = exptilde(psh, p, flag);
    250251                        }
    251252                        break;
    252253                default:
    253                         STPUTC(psh, c, expdest);
     254                        STPUTC(psh, c, psh->expdest);
    254255                        if (flag & EXP_IFS_SPLIT & ifs_split && strchr(ifs, c) != NULL) {
    255256                                /* We need to get the output split here... */
    256                                 recordregion(expdest - stackblock(psh) - 1,
    257                                                 expdest - stackblock(psh), 0);
     257                                recordregion(psh, (int)(psh->expdest - stackblock(psh) - 1),
     258                                                (int)(psh->expdest - stackblock(psh)), 0);
    258259                        }
    259260                        break;
     
    263264
    264265STATIC char *
    265 exptilde(char *p, int flag)
     266exptilde(shinstance *psh, char *p, int flag)
    266267{
    267268        char c, *startp = p;
     
    300301        while ((c = *home++) != '\0') {
    301302                if (quotes && SQSYNTAX[(int)c] == CCTL)
    302                         STPUTC(psh, CTLESC, expdest);
    303                 STPUTC(psh, c, expdest);
     303                        STPUTC(psh, CTLESC, psh->expdest);
     304                STPUTC(psh, c, psh->expdest);
    304305        }
    305306        return (p);
     
    311312
    312313STATIC void
    313 removerecordregions(int endoff)
    314 {
    315         if (ifslastp == NULL)
     314removerecordregions(shinstance *psh, int endoff)
     315{
     316        if (psh->ifslastp == NULL)
    316317                return;
    317318
    318         if (ifsfirst.endoff > endoff) {
    319                 while (ifsfirst.next != NULL) {
     319        if (psh->ifsfirst.endoff > endoff) {
     320                while (psh->ifsfirst.next != NULL) {
    320321                        struct ifsregion *ifsp;
    321322                        INTOFF;
    322                         ifsp = ifsfirst.next->next;
    323                         ckfree(ifsfirst.next);
    324                         ifsfirst.next = ifsp;
     323                        ifsp = psh->ifsfirst.next->next;
     324                        ckfree(psh->ifsfirst.next);
     325                        psh->ifsfirst.next = ifsp;
    325326                        INTON;
    326327                }
    327                 if (ifsfirst.begoff > endoff)
    328                         ifslastp = NULL;
     328                if (psh->ifsfirst.begoff > endoff)
     329                        psh->ifslastp = NULL;
    329330                else {
    330                         ifslastp = &ifsfirst;
    331                         ifsfirst.endoff = endoff;
     331                        psh->ifslastp = &psh->ifsfirst;
     332                        psh->ifsfirst.endoff = endoff;
    332333                }
    333334                return;
    334335        }
    335336
    336         ifslastp = &ifsfirst;
    337         while (ifslastp->next && ifslastp->next->begoff < endoff)
    338                 ifslastp=ifslastp->next;
    339         while (ifslastp->next != NULL) {
     337        psh->ifslastp = &psh->ifsfirst;
     338        while (psh->ifslastp->next && psh->ifslastp->next->begoff < endoff)
     339                psh->ifslastp=psh->ifslastp->next;
     340        while (psh->ifslastp->next != NULL) {
    340341                struct ifsregion *ifsp;
    341342                INTOFF;
    342                 ifsp = ifslastp->next->next;
    343                 ckfree(ifslastp->next);
    344                 ifslastp->next = ifsp;
     343                ifsp = psh->ifslastp->next->next;
     344                ckfree(psh->ifslastp->next);
     345                psh->ifslastp->next = ifsp;
    345346                INTON;
    346347        }
    347         if (ifslastp->endoff > endoff)
    348                 ifslastp->endoff = endoff;
     348        if (psh->ifslastp->endoff > endoff)
     349                psh->ifslastp->endoff = endoff;
    349350}
    350351
     
    355356 */
    356357void
    357 expari(int flag)
     358expari(shinstance *psh, int flag)
    358359{
    359360        char *p, *start;
     
    378379#error "integers with more than 10 digits are not supported"
    379380#endif
    380         CHECKSTRSPACE(psh, 12 - 2, expdest);
    381         USTPUTC(psh, '\0', expdest);
     381        CHECKSTRSPACE(psh, 12 - 2, psh->expdest);
     382        USTPUTC(psh, '\0', psh->expdest);
    382383        start = stackblock(psh);
    383         p = expdest - 1;
     384        p = psh->expdest - 1;
    384385        while (*p != CTLARI && p >= start)
    385386                --p;
     
    395396        else
    396397                quoted=0;
    397         begoff = p - start;
    398         removerecordregions(begoff);
     398        begoff = (int)(p - start);
     399        removerecordregions(psh, begoff);
    399400        if (quotes)
    400401                rmescapes(psh, p+2);
     
    406407
    407408        if (quoted == 0)
    408                 recordregion(begoff, p - 1 - start, 0);
    409         result = expdest - p + 1;
    410         STADJUST(psh, -result, expdest);
     409                recordregion(psh, begoff, (int)(p - 1 - start), 0);
     410        result = (int)(psh->expdest - p + 1);
     411        STADJUST(psh, -result, psh->expdest);
    411412}
    412413
     
    417418
    418419STATIC void
    419 expbackq(union node *cmd, int quoted, int flag)
     420expbackq(shinstance *psh, union node *cmd, int quoted, int flag)
    420421{
    421422        struct backcmd in;
     
    423424        char buf[128];
    424425        char *p;
    425         char *dest = expdest;
     426        char *dest = psh->expdest;
    426427        struct ifsregion saveifs, *savelastp;
    427428        struct nodelist *saveargbackq;
    428429        char lastc;
    429         int startloc = dest - stackblock(psh);
     430        int startloc = (int)(dest - stackblock(psh));
    430431        char const *syntax = quoted? DQSYNTAX : BASESYNTAX;
    431432        int saveherefd;
     
    433434
    434435        INTOFF;
    435         saveifs = ifsfirst;
    436         savelastp = ifslastp;
    437         saveargbackq = argbackq;
     436        saveifs = psh->ifsfirst;
     437        savelastp = psh->ifslastp;
     438        saveargbackq = psh->argbackq;
    438439        saveherefd = psh->herefd;
    439440        psh->herefd = -1;
     
    441442        evalbackcmd(psh, cmd, &in);
    442443        ungrabstackstr(psh, p, dest);
    443         ifsfirst = saveifs;
    444         ifslastp = savelastp;
    445         argbackq = saveargbackq;
     444        psh->ifsfirst = saveifs;
     445        psh->ifslastp = savelastp;
     446        psh->argbackq = saveargbackq;
    446447        psh->herefd = saveherefd;
    447448
     
    477478                ckfree(in.buf);
    478479        if (in.jp)
    479                 back_exitstatus = waitforjob(psh, in.jp);
     480                psh->back_exitstatus = waitforjob(psh, in.jp);
    480481        if (quoted == 0)
    481                 recordregion(startloc, dest - stackblock(psh), 0);
     482                recordregion(psh, startloc, (int)(dest - stackblock(psh)), 0);
    482483        TRACE((psh, "evalbackq: size=%d: \"%.*s\"\n",
    483484                (dest - stackblock(psh)) - startloc,
    484485                (dest - stackblock(psh)) - startloc,
    485486                stackblock(psh) + startloc));
    486         expdest = dest;
     487        psh->expdest = dest;
    487488        INTON;
    488489}
     
    491492
    492493STATIC int
    493 subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags)
     494subevalvar(shinstance *psh, char *p, char *str, int strloc, int subtype, int startloc, int varflags)
    494495{
    495496        char *startp;
     
    498499        int c = 0;
    499500        int saveherefd = psh->herefd;
    500         struct nodelist *saveargbackq = argbackq;
     501        struct nodelist *saveargbackq = psh->argbackq;
    501502        int amount;
    502503
    503504        psh->herefd = -1;
    504         argstr(p, 0);
    505         STACKSTRNUL(psh, expdest);
     505        argstr(psh, p, 0);
     506        STACKSTRNUL(psh, psh->expdest);
    506507        psh->herefd = saveherefd;
    507         argbackq = saveargbackq;
     508        psh->argbackq = saveargbackq;
    508509        startp = stackblock(psh) + startloc;
    509510        if (str == NULL)
     
    513514        case VSASSIGN:
    514515                setvar(psh, str, startp, 0);
    515                 amount = startp - expdest;
    516                 STADJUST(psh, amount, expdest);
     516                amount = (int)(startp - psh->expdest);
     517                STADJUST(psh, amount, psh->expdest);
    517518                varflags &= ~VSNUL;
    518519                if (c != 0)
     
    592593recordleft:
    593594        *loc = c;
    594         amount = ((str - 1) - (loc - startp)) - expdest;
    595         STADJUST(psh, amount, expdest);
     595        amount = (int)(((str - 1) - (loc - startp)) - psh->expdest);
     596        STADJUST(psh, amount, psh->expdest);
    596597        while (loc != str - 1)
    597598                *startp++ = *loc++;
     
    599600
    600601recordright:
    601         amount = loc - expdest;
    602         STADJUST(psh, amount, expdest);
    603         STPUTC(psh, '\0', expdest);
    604         STADJUST(psh, -1, expdest);
     602        amount = (int)(loc - psh->expdest);
     603        STADJUST(psh, amount, psh->expdest);
     604        STPUTC(psh, '\0', psh->expdest);
     605        STADJUST(psh, -1, psh->expdest);
    605606        return 1;
    606607}
     
    613614
    614615STATIC char *
    615 evalvar(char *p, int flag)
     616evalvar(shinstance *psh, char *p, int flag)
    616617{
    617618        int subtype;
     
    636637again: /* jump here after setting a variable with ${var=text} */
    637638        if (special) {
    638                 set = varisset(var, varflags & VSNUL);
     639                set = varisset(psh, var, varflags & VSNUL);
    639640                val = NULL;
    640641        } else {
     
    648649
    649650        varlen = 0;
    650         startloc = expdest - stackblock(psh);
     651        startloc = (int)(psh->expdest - stackblock(psh));
    651652
    652653        if (!set && uflag(psh)) {
     
    666667                /* insert the value of the variable */
    667668                if (special) {
    668                         varvalue(var, varflags & VSQUOTE, subtype, flag);
     669                        varvalue(psh, var, varflags & VSQUOTE, subtype, flag);
    669670                        if (subtype == VSLENGTH) {
    670                                 varlen = expdest - stackblock(psh) - startloc;
    671                                 STADJUST(psh, -varlen, expdest);
     671                                varlen = (int)(psh->expdest - stackblock(psh) - startloc);
     672                                STADJUST(psh, -varlen, psh->expdest);
    672673                        }
    673674                } else {
     
    681682                                while (*val) {
    682683                                        if (quotes && syntax[(int)*val] == CCTL)
    683                                                 STPUTC(psh, CTLESC, expdest);
    684                                         STPUTC(psh, *val++, expdest);
     684                                                STPUTC(psh, CTLESC, psh->expdest);
     685                                        STPUTC(psh, *val++, psh->expdest);
    685686                                }
    686687
     
    691692
    692693        apply_ifs = ((varflags & VSQUOTE) == 0 ||
    693                 (*var == '@' && shellparam.nparam != 1));
     694                (*var == '@' && psh->shellparam.nparam != 1));
    694695
    695696        switch (subtype) {
    696697        case VSLENGTH:
    697                 expdest = cvtnum(varlen, expdest);
     698                psh->expdest = cvtnum(psh, varlen, psh->expdest);
    698699                break;
    699700
     
    706707        case VSMINUS:
    707708                if (!set) {
    708                         argstr(p, flag | (apply_ifs ? EXP_IFS_SPLIT : 0));
     709                        argstr(psh, p, flag | (apply_ifs ? EXP_IFS_SPLIT : 0));
    709710                        /*
    710711                         * ${x-a b c} doesn't get split, but removing the
     
    727728                 * right after it
    728729                 */
    729                 STPUTC(psh, '\0', expdest);
    730                 patloc = expdest - stackblock(psh);
    731                 if (subevalvar(p, NULL, patloc, subtype,
     730                STPUTC(psh, '\0', psh->expdest);
     731                patloc = (int)(psh->expdest - stackblock(psh));
     732                if (subevalvar(psh, p, NULL, patloc, subtype,
    732733                               startloc, varflags) == 0) {
    733                         int amount = (expdest - stackblock(psh) - patloc) + 1;
    734                         STADJUST(psh, -amount, expdest);
     734                        int amount = (int)(psh->expdest - stackblock(psh) - patloc) + 1;
     735                        STADJUST(psh, -amount, psh->expdest);
    735736                }
    736737                /* Remove any recorded regions beyond start of variable */
    737                 removerecordregions(startloc);
     738                removerecordregions(psh, startloc);
    738739                apply_ifs = 1;
    739740                break;
     
    743744                if (set)
    744745                        break;
    745                 if (subevalvar(p, var, 0, subtype, startloc, varflags)) {
     746                if (subevalvar(psh, p, var, 0, subtype, startloc, varflags)) {
    746747                        varflags &= ~VSNUL;
    747748                        /*
     
    749750                         * start of variable
    750751                         */
    751                         removerecordregions(startloc);
     752                        removerecordregions(psh, startloc);
    752753                        goto again;
    753754                }
     
    760761
    761762        if (apply_ifs)
    762                 recordregion(startloc, expdest - stackblock(psh),
     763                recordregion(psh, startloc, (int)(psh->expdest - stackblock(psh)),
    763764                             varflags & VSQUOTE);
    764765
     
    770771                        else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
    771772                                if (set)
    772                                         argbackq = argbackq->next;
     773                                        psh->argbackq = psh->argbackq->next;
    773774                        } else if (c == CTLVAR) {
    774775                                if ((*p++ & VSTYPE) != VSNORMAL)
     
    790791
    791792STATIC int
    792 varisset(char *name, int nulok)
     793varisset(shinstance *psh, char *name, int nulok)
    793794{
    794795        if (*name == '!')
    795                 return backgndpid != -1;
     796                return psh->backgndpid != -1;
    796797        else if (*name == '@' || *name == '*') {
    797                 if (*shellparam.p == NULL)
     798                if (*psh->shellparam.p == NULL)
    798799                        return 0;
    799800
     
    801802                        char **av;
    802803
    803                         for (av = shellparam.p; *av; av++)
     804                        for (av = psh->shellparam.p; *av; av++)
    804805                                if (**av != '\0')
    805806                                        return 1;
     
    810811                int num = atoi(name);
    811812
    812                 if (num > shellparam.nparam)
     813                if (num > psh->shellparam.nparam)
    813814                        return 0;
    814815
    815816                if (num == 0)
    816                         ap = arg0;
     817                        ap = psh->arg0;
    817818                else
    818                         ap = shellparam.p[num - 1];
     819                        ap = psh->shellparam.p[num - 1];
    819820
    820821                if (nulok && (ap == NULL || *ap == '\0'))
     
    831832
    832833STATIC void
    833 varvalue(char *name, int quoted, int subtype, int flag)
     834varvalue(shinstance *psh, char *name, int quoted, int subtype, int flag)
    834835{
    835836        int num;
     
    846847                while (*p) { \
    847848                        if (syntax[(int)*p] == CCTL) \
    848                                 STPUTC(psh, CTLESC, expdest); \
    849                         STPUTC(psh, *p++, expdest); \
     849                                STPUTC(psh, CTLESC, psh->expdest); \
     850                        STPUTC(psh, *p++, psh->expdest); \
    850851                } \
    851852        } else \
    852853                while (*p) \
    853                         STPUTC(psh, *p++, expdest); \
     854                        STPUTC(psh, *p++, psh->expdest); \
    854855        } while (0)
    855856
     
    857858        switch (*name) {
    858859        case '$':
    859                 num = rootpid;
     860                num = psh->rootpid;
    860861                goto numvar;
    861862        case '?':
    862                 num = exitstatus;
     863                num = psh->exitstatus;
    863864                goto numvar;
    864865        case '#':
    865                 num = shellparam.nparam;
     866                num = psh->shellparam.nparam;
    866867                goto numvar;
    867868        case '!':
    868                 num = backgndpid;
     869                num = psh->backgndpid;
    869870numvar:
    870                 expdest = cvtnum(num, expdest);
     871                psh->expdest = cvtnum(psh, num, psh->expdest);
    871872                break;
    872873        case '-':
    873                 for (i = 0; optlist[i].name; i++) {
    874                         if (optlist[i].val)
    875                                 STPUTC(psh, optlist[i].letter, expdest);
     874                for (i = 0; psh->optlist[i].name; i++) {
     875                        if (psh->optlist[i].val)
     876                                STPUTC(psh, psh->optlist[i].letter, psh->expdest);
    876877                }
    877878                break;
    878879        case '@':
    879880                if (flag & EXP_FULL && quoted) {
    880                         for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
     881                        for (ap = psh->shellparam.p ; (p = *ap++) != NULL ; ) {
    881882                                STRTODEST(p);
    882883                                if (*ap)
    883                                         STPUTC(psh, '\0', expdest);
     884                                        STPUTC(psh, '\0', psh->expdest);
    884885                        }
    885886                        break;
     
    887888                /* fall through */
    888889        case '*':
    889                 if (ifsset() != 0)
    890                         sep = ifsval()[0];
     890                if (ifsset(psh) != 0)
     891                        sep = ifsval(psh)[0];
    891892                else
    892893                        sep = ' ';
    893                 for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
     894                for (ap = psh->shellparam.p ; (p = *ap++) != NULL ; ) {
    894895                        STRTODEST(p);
    895896                        if (*ap && sep)
    896                                 STPUTC(psh, sep, expdest);
     897                                STPUTC(psh, sep, psh->expdest);
    897898                }
    898899                break;
    899900        case '0':
    900                 p = arg0;
     901                p = psh->arg0;
    901902                STRTODEST(p);
    902903                break;
     
    904905                if (is_digit(*name)) {
    905906                        num = atoi(name);
    906                         if (num > 0 && num <= shellparam.nparam) {
    907                                 p = shellparam.p[num - 1];
     907                        if (num > 0 && num <= psh->shellparam.nparam) {
     908                                p = psh->shellparam.p[num - 1];
    908909                                STRTODEST(p);
    909910                        }
     
    921922
    922923STATIC void
    923 recordregion(int start, int end, int inquotes)
     924recordregion(shinstance *psh, int start, int end, int inquotes)
    924925{
    925926        struct ifsregion *ifsp;
    926927
    927         if (ifslastp == NULL) {
    928                 ifsp = &ifsfirst;
     928        if (psh->ifslastp == NULL) {
     929                ifsp = &psh->ifsfirst;
    929930        } else {
    930                 if (ifslastp->endoff == start
    931                     && ifslastp->inquotes == inquotes) {
     931                if (psh->ifslastp->endoff == start
     932                    && psh->ifslastp->inquotes == inquotes) {
    932933                        /* extend previous area */
    933                         ifslastp->endoff = end;
     934                        psh->ifslastp->endoff = end;
    934935                        return;
    935936                }
    936937                ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
    937                 ifslastp->next = ifsp;
    938         }
    939         ifslastp = ifsp;
    940         ifslastp->next = NULL;
    941         ifslastp->begoff = start;
    942         ifslastp->endoff = end;
    943         ifslastp->inquotes = inquotes;
     938                psh->ifslastp->next = ifsp;
     939        }
     940        psh->ifslastp = ifsp;
     941        psh->ifslastp->next = NULL;
     942        psh->ifslastp->begoff = start;
     943        psh->ifslastp->endoff = end;
     944        psh->ifslastp->inquotes = inquotes;
    944945}
    945946
     
    952953 */
    953954STATIC void
    954 ifsbreakup(char *string, struct arglist *arglist)
     955ifsbreakup(shinstance *psh, char *string, struct arglist *arglist)
    955956{
    956957        struct ifsregion *ifsp;
     
    967968        inquotes = 0;
    968969
    969         if (ifslastp == NULL) {
     970        if (psh->ifslastp == NULL) {
    970971                /* Return entire argument, IFS doesn't apply to any of it */
    971972                sp = (struct strlist *)stalloc(psh, sizeof *sp);
     
    976977        }
    977978
    978         ifs = ifsset() ? ifsval() : " \t\n";
    979 
    980         for (ifsp = &ifsfirst; ifsp != NULL; ifsp = ifsp->next) {
     979        ifs = ifsset(psh) ? ifsval(psh) : " \t\n";
     980
     981        for (ifsp = &psh->ifsfirst; ifsp != NULL; ifsp = ifsp->next) {
    981982                p = string + ifsp->begoff;
    982983                inquotes = ifsp->inquotes;
     
    10511052
    10521053STATIC void
    1053 ifsfree(void)
    1054 {
    1055         while (ifsfirst.next != NULL) {
     1054ifsfree(shinstance *psh)
     1055{
     1056        while (psh->ifsfirst.next != NULL) {
    10561057                struct ifsregion *ifsp;
    10571058                INTOFF;
    1058                 ifsp = ifsfirst.next->next;
    1059                 ckfree(ifsfirst.next);
    1060                 ifsfirst.next = ifsp;
     1059                ifsp = psh->ifsfirst.next->next;
     1060                ckfree(psh->ifsfirst.next);
     1061                psh->ifsfirst.next = ifsp;
    10611062                INTON;
    10621063        }
    1063         ifslastp = NULL;
    1064         ifsfirst.next = NULL;
     1064        psh->ifslastp = NULL;
     1065        psh->ifsfirst.next = NULL;
    10651066}
    10661067
     
    10691070/*
    10701071 * Expand shell metacharacters.  At this point, the only control characters
    1071  * should be escapes.  The results are stored in the list exparg.
    1072  */
    1073 
    1074 char *expdir;
     1072 * should be escapes.  The results are stored in the list psh->exparg.
     1073 */
     1074
     1075//char *expdir;
    10751076
    10761077
    10771078STATIC void
    1078 expandmeta(struct strlist *str, int flag)
     1079expandmeta(shinstance *psh, struct strlist *str, int flag)
    10791080{
    10801081        char *p;
     
    10941095                                break;
    10951096                }
    1096                 savelastp = exparg.lastp;
     1097                savelastp = psh->exparg.lastp;
    10971098                INTOFF;
    1098                 if (expdir == NULL) {
    1099                         int i = strlen(str->text);
    1100                         expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
    1101                 }
    1102 
    1103                 expmeta(expdir, str->text);
    1104                 ckfree(expdir);
    1105                 expdir = NULL;
     1099                if (psh->expdir == NULL) {
     1100                        size_t i = strlen(str->text);
     1101                        psh->expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
     1102                }
     1103
     1104                expmeta(psh, psh->expdir, str->text);
     1105                ckfree(psh->expdir);
     1106                psh->expdir = NULL;
    11061107                INTON;
    1107                 if (exparg.lastp == savelastp) {
     1108                if (psh->exparg.lastp == savelastp) {
    11081109                        /*
    11091110                         * no matches
    11101111                         */
    11111112nometa:
    1112                         *exparg.lastp = str;
     1113                        *psh->exparg.lastp = str;
    11131114                        rmescapes(psh, str->text);
    1114                         exparg.lastp = &str->next;
     1115                        psh->exparg.lastp = &str->next;
    11151116                } else {
    1116                         *exparg.lastp = NULL;
     1117                        *psh->exparg.lastp = NULL;
    11171118                        *savelastp = sp = expsort(*savelastp);
    11181119                        while (sp->next != NULL)
    11191120                                sp = sp->next;
    1120                         exparg.lastp = &sp->next;
     1121                        psh->exparg.lastp = &sp->next;
    11211122                }
    11221123                str = str->next;
     
    11301131
    11311132STATIC void
    1132 expmeta(char *enddir, char *name)
     1133expmeta(shinstance *psh, char *enddir, char *name)
    11331134{
    11341135        char *p;
     
    11801181        }
    11811182        if (metaflag == 0) {    /* we've reached the end of the file name */
    1182                 if (enddir != expdir)
     1183                if (enddir != psh->expdir)
    11831184                        metaflag++;
    11841185                for (p = name ; ; p++) {
     
    11911192                                break;
    11921193                }
    1193                 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
    1194                         addfname(expdir);
     1194                if (metaflag == 0 || lstat(psh->expdir, &statb) >= 0)
     1195                        addfname(psh, psh->expdir);
    11951196                return;
    11961197        }
     
    12061207                }
    12071208        }
    1208         if (enddir == expdir) {
     1209        if (enddir == psh->expdir) {
    12091210                cp = ".";
    1210         } else if (enddir == expdir + 1 && *expdir == '/') {
     1211        } else if (enddir == psh->expdir + 1 && *psh->expdir == '/') {
    12111212                cp = "/";
    12121213        } else {
    1213                 cp = expdir;
     1214                cp = psh->expdir;
    12141215                enddir[-1] = '\0';
    12151216        }
    12161217        if ((dirp = opendir(cp)) == NULL)
    12171218                return;
    1218         if (enddir != expdir)
     1219        if (enddir != psh->expdir)
    12191220                enddir[-1] = '/';
    12201221        if (*endname == 0) {
     
    12381239                        if (atend) {
    12391240                                scopy(dp->d_name, enddir);
    1240                                 addfname(expdir);
     1241                                addfname(psh, psh->expdir);
    12411242                        } else {
    12421243                                for (p = enddir, cp = dp->d_name;
     
    12441245                                        continue;
    12451246                                p[-1] = '/';
    1246                                 expmeta(p, endname);
     1247                                expmeta(psh, p, endname);
    12471248                        }
    12481249                }
     
    12591260
    12601261STATIC void
    1261 addfname(char *name)
     1262addfname(shinstance *psh, char *name)
    12621263{
    12631264        char *p;
     
    12681269        sp = (struct strlist *)stalloc(psh, sizeof *sp);
    12691270        sp->text = p;
    1270         *exparg.lastp = sp;
    1271         exparg.lastp = &sp->next;
     1271        *psh->exparg.lastp = sp;
     1272        psh->exparg.lastp = &sp->next;
    12721273}
    12731274
     
    13391340
    13401341int
    1341 patmatch(char *pattern, char *string, int squoted)
     1342patmatch(shinstance *psh, char *pattern, char *string, int squoted)
    13421343{
    13431344#ifdef notdef
     
    14741475
    14751476void
    1476 rmescapes(char *str)
     1477rmescapes(shinstance *psh, char *str)
    14771478{
    14781479        char *p, *q;
     
    15031504
    15041505int
    1505 casematch(union node *pattern, char *val)
     1506casematch(shinstance *psh, union node *pattern, char *val)
    15061507{
    15071508        struct stackmark smark;
     
    15101511
    15111512        setstackmark(psh, &smark);
    1512         argbackq = pattern->narg.backquote;
    1513         STARTSTACKSTR(psh, expdest);
    1514         ifslastp = NULL;
    1515         argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
    1516         STPUTC(psh, '\0', expdest);
    1517         p = grabstackstr(psh, expdest);
     1513        psh->argbackq = pattern->narg.backquote;
     1514        STARTSTACKSTR(psh, psh->expdest);
     1515        psh->ifslastp = NULL;
     1516        argstr(psh, pattern->narg.text, EXP_TILDE | EXP_CASE);
     1517        STPUTC(psh, '\0', psh->expdest);
     1518        p = grabstackstr(psh, psh->expdest);
    15181519        result = patmatch(psh, p, val, 0);
    15191520        popstackmark(psh, &smark);
     
    15261527
    15271528STATIC char *
    1528 cvtnum(int num, char *buf)
     1529cvtnum(shinstance *psh, int num, char *buf)
    15291530{
    15301531        char temp[32];
  • trunk/src/kash/expand.h

    r884 r1203  
    3434 *      @(#)expand.h    8.2 (Berkeley) 5/4/95
    3535 */
     36
     37#ifndef ___expand_h
     38#define ___expand_h
    3639
    3740struct strlist {
     
    7174void arith_lex_reset(void);
    7275int yylex(void);
     76
     77#endif
  • trunk/src/kash/generated/init.c

    r1202 r1203  
    210210      /* from eval.c: */
    211211      {
    212               evalskip = 0;
    213               loopnest = 0;
    214               funcnest = 0;
     212              psh->evalskip = 0;
     213              psh->loopnest = 0;
     214              psh->funcnest = 0;
    215215      }
    216216
    217217      /* from input.c: */
    218218      {
    219               if (exception != EXSHELLPROC)
    220                       parselleft = parsenleft = 0;      /* clear input buffer */
     219              if (psh->exception != EXSHELLPROC)
     220                      psh->parselleft = psh->parsenleft = 0;    /* clear input buffer */
    221221              popallfiles(psh);
    222222      }
     
    234234      /* from parser.c: */
    235235      {
    236               tokpushback = 0;
    237               checkkwd = 0;
     236              psh->tokpushback = 0;
     237              psh->checkkwd = 0;
    238238      }
    239239
    240240      /* from redir.c: */
    241241      {
    242               while (redirlist)
     242              while (psh->redirlist)
    243243                      popredir(psh);
    244244      }
     
    261261      /* from eval.c: */
    262262      {
    263               exitstatus = 0;
     263              psh->exitstatus = 0;
    264264      }
    265265
     
    276276      /* from jobs.c: */
    277277      {
    278               backgndpid = -1;
     278              psh->backgndpid = -1;
    279279#if JOBS
    280280              jobctl = 0;
  • trunk/src/kash/histedit.c

    r1202 r1203  
    130130                        else
    131131                                unsetenv("TERM");
    132                         shname = arg0;
     132                        shname = psh->arg0;
    133133                        if (shname[0] == '-')
    134134                                shname++;
  • trunk/src/kash/jobs.c

    r1202 r1203  
    9494static int njobs;                       /* size of array */
    9595static int jobs_invalid;                /* set in child */
    96 MKINIT pid_t backgndpid = -1;   /* pid of last background process */
     96MKINIT pid_t psh->backgndpid = -1;      /* pid of last background process */
    9797#if JOBS
    9898int initialpgrp;                /* pgrp of shell on invocation */
     
    215215                setsignal(psh, SIGTTOU, 0);
    216216                setsignal(psh, SIGTTIN, 0);
    217                 if (getpgid(0) != rootpid && setpgid(0, rootpid) == -1)
     217                if (getpgid(0) != psh->rootpid && sh_setpgid(0, psh->rootpid) == -1)
    218218                        error(psh, "Cannot set process group (%s) at %d",
    219219                            strerror(errno), __LINE__);
    220                 if (tcsetpgrp(ttyfd, rootpid) == -1)
     220                if (tcsetpgrp(ttyfd, psh->rootpid) == -1)
    221221                        error(psh, "Cannot set tty process group (%s) at %d",
    222222                            strerror(errno), __LINE__);
    223223        } else { /* turning job control off */
    224                 if (getpgid(0) != initialpgrp && setpgid(0, initialpgrp) == -1)
     224                if (getpgid(0) != initialpgrp && sh_setpgid(0, initialpgrp) == -1)
    225225                        error(psh, "Cannot set process group (%s) at %d",
    226226                            strerror(errno), __LINE__);
     
    242242
    243243SHELLPROC {
    244         backgndpid = -1;
    245 #if JOBS
    246         jobctl = 0;
     244        psh->backgndpid = -1;
     245#if JOBS
     246        psh->jobctl = 0;
    247247#endif
    248248}
     
    511511                else
    512512                        mode = SHOW_PGID;
    513         if (*argptr)
     513        if (*psh->argptr)
    514514                do
    515                         showjob(out1, getjob(*argptr,0), mode);
    516                 while (*++argptr);
     515                        showjob(out1, getjob(*psh->argptr,0), mode);
     516                while (*++psh->argptr);
    517517        else
    518518                showjobs(psh, out1, mode);
     
    608608        nextopt(psh, "");
    609609
    610         if (!*argptr) {
     610        if (!*psh->argptr) {
    611611                /* wait for all jobs */
    612612                jp = jobtab;
     
    629629
    630630        retval = 127;           /* XXXGCC: -Wuninitialized */
    631         for (; *argptr; argptr++) {
    632                 job = getjob(*argptr, 1);
     631        for (; *psh->argptr; psh->argptr++) {
     632                job = getjob(*psh->argptr, 1);
    633633                if (!job) {
    634634                        retval = 127;
     
    666666
    667667        nextopt(psh, "");
    668         jp = getjob(*argptr, 0);
     668        jp = getjob(*psh->argptr, 0);
    669669        for (i = 0 ; i < jp->nprocs ; ) {
    670670                out1fmt(psh, "%ld", (long)jp->ps[i].pid);
     
    879879        }
    880880        if (mode == FORK_BG)
    881                 backgndpid = pid;               /* set $! */
     881                psh0->backgndpid = pid;         /* set $! */
    882882        if (jp) {
    883883                struct procstat *ps = &jp->ps[jp->nprocs++];
  • trunk/src/kash/miscbltin.c

    r1202 r1203  
    117117        }
    118118
    119         if (*(ap = argptr) == NULL)
     119        if (*(ap = psh->argptr) == NULL)
    120120                error(psh, "arg count");
    121121
     
    230230        INTON;
    231231
    232         if ((ap = *argptr) == NULL) {
     232        if ((ap = *psh->argptr) == NULL) {
    233233                if (symbolic_mode) {
    234234                        char u[4], g[4], o[4];
     
    386386                error(psh, "internal error (%c)", what);
    387387
    388         set = *argptr ? 1 : 0;
     388        set = *psh->argptr ? 1 : 0;
    389389        if (set) {
    390                 char *p = *argptr;
    391 
    392                 if (all || argptr[1])
     390                char *p = *psh->argptr;
     391
     392                if (all || psh->argptr[1])
    393393                        error(psh, "too many arguments");
    394394                if (strcmp(p, "unlimited") == 0)
  • trunk/src/kash/shinstance.h

    r1201 r1203  
    3636#include "options.h"
    3737
     38#include "expand.h"
     39#include "exec.h"
    3840#include "var.h"
    3941
     
    7072};
    7173
     74/* exec.c */
     75#define CMDTABLESIZE 31         /* should be prime */
     76#define ARB 1                   /* actual size determined at run time */
     77
     78struct tblentry {
     79        struct tblentry *next;  /* next entry in hash chain */
     80        union param param;      /* definition of builtin function */
     81        short cmdtype;          /* index identifying command */
     82        char rehash;            /* if set, cd done since entry created */
     83        char cmdname[ARB];      /* name of command */
     84};
     85
     86/* expand.c */
     87/*
     88 * Structure specifying which parts of the string should be searched
     89 * for IFS characters.
     90 */
     91struct ifsregion {
     92        struct ifsregion *next; /* next region in list */
     93        int begoff;             /* offset of start of region */
     94        int endoff;             /* offset of end of region */
     95        int inquotes;           /* search for nul bytes only */
     96};
    7297
    7398
     
    91116    struct jmploc      *handler;
    92117    int                 exception;
    93     int                 exerrno;
     118    int                 exerrno/* = 0 */; /**< Last exec error */
    94119    int volatile        suppressint;
    95120    int volatile        intpending;
     
    188213    const char         *pathopt;        /**< set by padvance */
    189214
     215    /* exec.c */
     216    struct tblentry    *cmdtable[CMDTABLESIZE];
     217    int                 builtinloc/* = -1*/;    /**< index in path of %builtin, or -1 */
     218
     219
    190220    /* eval.h */
    191221    char               *commandname;    /**< currently executing command */
     
    215245    /* eval.c */
    216246    int                 vforked;
     247
     248    /* expand.c */
     249    char               *expdest;        /**< output of current string */
     250    struct nodelist    *argbackq;       /**< list of back quote expressions */
     251    struct ifsregion    ifsfirst;       /**< first struct in list of ifs regions */
     252    struct ifsregion   *ifslastp;       /**< last struct in list */
     253    struct arglist      exparg;         /**< holds expanded arg list */
     254    char               *expdir;         /**< Used by expandmeta. */
    217255
    218256    /* mail.c */
     
    259297int sh_sysconf_clk_tck(void);
    260298
    261 /* wait */
     299/* wait / process */
    262300#ifdef _MSC_VER
    263301#   include <process.h>
     
    284322pid_t sh_waitpid(shinstance *, pid_t, int *, int);
    285323void sh__exit(shinstance *, int);
    286 
    287 
    288 #endif
     324int sh_execve(shinstance *, const char *, const char * const*, const char * const *);
     325
     326#endif
  • trunk/src/kash/trap.c

    r1202 r1203  
    401401        for (;;) {
    402402                for (i = 1 ; ; i++) {
    403                         if (gotsig[i - 1])
     403                        if (psh->gotsig[i - 1])
    404404                                break;
    405405                        if (i >= NSIG)
    406406                                goto done;
    407407                }
    408                 gotsig[i - 1] = 0;
    409                 savestatus=exitstatus;
     408                psh->gotsig[i - 1] = 0;
     409                savestatus=psh->exitstatus;
    410410                evalstring(psh, trap[i], 0);
    411                 exitstatus=savestatus;
     411                psh->exitstatus=savestatus;
    412412        }
    413413done:
    414         pendingsigs = 0;
     414        psh->pendingsigs = 0;
    415415}
    416416
  • trunk/src/kash/var.c

    r1202 r1203  
    681681        }
    682682
    683         while ((name = *argptr++) != NULL) {
     683        while ((name = *psh->argptr++) != NULL) {
    684684                if ((p = strchr(name, '=')) != NULL) {
    685685                        p++;
     
    708708        if (! in_function(psh))
    709709                error(psh, "Not in a function");
    710         while ((name = *argptr++) != NULL) {
     710        while ((name = *psh->argptr++) != NULL) {
    711711                mklocal(psh, name, 0);
    712712        }
     
    830830                flg_var = 1;
    831831
    832         for (ap = argptr; *ap ; ap++) {
     832        for (ap = psh->argptr; *ap ; ap++) {
    833833                if (flg_func)
    834834                        ret |= unsetfunc(psh, *ap);
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