VirtualBox

Changeset 2290 in kBuild


Ignore:
Timestamp:
Feb 27, 2009 4:08:07 AM (16 years ago)
Author:
bird
Message:

kash: malloc/free/friends gets a psh.

Location:
trunk/src/kash
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/alias.c

    r1233 r2290  
    7171                if (equal(name, ap->name)) {
    7272                        INTOFF;
    73                         ckfree(ap->val);
    74                         ap->val = savestr(val);
     73                        ckfree(psh, ap->val);
     74                        ap->val = savestr(psh, val);
    7575                        INTON;
    7676                        return;
    … …  
    7979        /* not found */
    8080        INTOFF;
    81         ap = ckmalloc(sizeof (struct alias));
    82         ap->name = savestr(name);
     81        ap = ckmalloc(psh, sizeof (struct alias));
     82        ap->name = savestr(psh, name);
    8383        /*
    8484         * XXX - HACK: in order that the parser will not finish reading the
    … …  
    9999         */
    100100#ifdef notyet
    101         ap->val = savestr(val);
     101        ap->val = savestr(psh, val);
    102102#else /* hack */
    103103        {
    104104        size_t len = strlen(val);
    105         ap->val = ckmalloc(len + 2);
     105        ap->val = ckmalloc(psh, len + 2);
    106106        memcpy(ap->val, val, len);
    107107        ap->val[len] = ' ';     /* fluff */
    … …  
    135135                                INTOFF;
    136136                                *app = ap->next;
    137                                 ckfree(ap->name);
    138                                 ckfree(ap->val);
    139                                 ckfree(ap);
     137                                ckfree(psh, ap->name);
     138                                ckfree(psh, ap->val);
     139                                ckfree(psh, ap);
    140140                                INTON;
    141141                        }
    … …  
    166166                psh->atab[i] = NULL;
    167167                while (ap) {
    168                         ckfree(ap->name);
    169                         ckfree(ap->val);
     168                        ckfree(psh, ap->name);
     169                        ckfree(psh, ap->val);
    170170                        tmp = ap;
    171171                        ap = ap->next;
    172                         ckfree(tmp);
     172                        ckfree(psh, tmp);
    173173                }
    174174        }

  • trunk/src/kash/cd.c

    r1236 r2290  
    253253        if (dir == NULL || psh->curdir == NULL)  {
    254254                if (psh->prevdir)
    255                         ckfree(psh->prevdir);
     255                        ckfree(psh, psh->prevdir);
    256256                INTOFF;
    257257                psh->prevdir = psh->curdir;
    … …  
    289289        INTOFF;
    290290        if (psh->prevdir)
    291                 ckfree(psh->prevdir);
     291                ckfree(psh, psh->prevdir);
    292292        psh->prevdir = psh->curdir;
    293         psh->curdir = savestr(stackblock(psh));
     293        psh->curdir = savestr(psh, stackblock(psh));
    294294        setvar(psh, "PWD", psh->curdir, VEXPORT);
    295295        INTON;
    … …  
    352352                    stdot.st_dev == stpwd.st_dev &&
    353353                    stdot.st_ino == stpwd.st_ino) {
    354                         psh->curdir = savestr(pwd);
     354                        psh->curdir = savestr(psh, pwd);
    355355                        return psh->curdir;
    356356                }
    … …  
    385385                pwd = stalloc(psh, i);
    386386                if (shfile_getcwd(&psh->fdtab, pwd, i) != NULL) {
    387                         psh->curdir = savestr(pwd);
     387                        psh->curdir = savestr(psh, pwd);
    388388                        return;
    389389                }

  • trunk/src/kash/eval.c

    r1233 r2290  
    614614        if (sys_path == NULL) {
    615615                if (sysctl(mib, 2, 0, &len, 0, 0) != -1 &&
    616                     (sys_path = ckmalloc(len + 5)) != NULL &&
     616                    (sys_path = ckmalloc(psh, len + 5)) != NULL &&
    617617                    sysctl(mib, 2, sys_path + 5, &len, 0, 0) != -1) {
    618618                        memcpy(sys_path, "PATH=", 5);
    619619                } else {
    620                         ckfree(sys_path);
     620                        ckfree(psh, sys_path);
    621621                        /* something to keep things happy */
    622622                        sys_path = def_path;
    … …  
    935935                if (setjmp(jmploc.loc)) {
    936936                        if (psh->exception == EXSHELLPROC) {
    937                                 freeparam((volatile struct shparam *)
     937                                freeparam(psh, (volatile struct shparam *)
    938938                                    &saveparam);
    939939                        } else {
    940                                 freeparam(&psh->shellparam);
     940                                freeparam(psh, &psh->shellparam);
    941941                                psh->shellparam = saveparam;
    942942                        }
    … …  
    957957                poplocalvars(psh);
    958958                psh->localvars = savelocalvars;
    959                 freeparam(&psh->shellparam);
     959                freeparam(psh, &psh->shellparam);
    960960                psh->shellparam = saveparam;
    961961                psh->handler = savehandler;

  • trunk/src/kash/exec.c

    r1233 r2290  
    213213                initshellproc(psh);
    214214                setinputfile(psh, cmd, 0);
    215                 psh->commandname = psh->arg0 = savestr(argv[0]);
     215                psh->commandname = psh->arg0 = savestr(psh, argv[0]);
    216216#ifdef EXEC_HASH_BANG_SCRIPT
    217217                pgetc(psh); pungetc(psh);               /* fill up input buffer */
    … …  
    296296                error(psh, "Bad #! line");
    297297        for (ap2 = argv ; *ap2++ != NULL ; );
    298         new = ckmalloc(i + ((char *)ap2 - (char *)argv));
     298        new = ckmalloc(psh, i + ((char *)ap2 - (char *)argv));
    299299        ap = newargs, ap2 = new;
    300300        while ((i -= sizeof (char **)) >= 0)
    … …  
    868868                             psh->builtinloc >= firstchange)) {
    869869                                *pp = cmdp->next;
    870                                 ckfree(cmdp);
     870                                ckfree(psh, cmdp);
    871871                        } else {
    872872                                pp = &cmdp->next;
    … …  
    908908                        if (cmdp->cmdtype == CMDFUNCTION) {
    909909                                *pp = cmdp->next;
    910                                 freefunc(cmdp->param.func);
    911                                 ckfree(cmdp);
     910                                freefunc(psh, cmdp->param.func);
     911                                ckfree(psh, cmdp);
    912912                        } else {
    913913                                pp = &cmdp->next;
    … …  
    952952        if (add && cmdp == NULL) {
    953953                INTOFF;
    954                 cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
     954                cmdp = *pp = ckmalloc(psh, sizeof (struct tblentry) - ARB
    955955                                        + strlen(name) + 1);
    956956                cmdp->next = NULL;
    … …  
    976976        cmdp = *lastcmdentry;
    977977        *lastcmdentry = cmdp->next;
    978         ckfree(cmdp);
     978        ckfree(psh, cmdp);
    979979        INTON;
    980980}
    … …  
    10131013        if (cmdp->cmdtype != CMDSPLBLTIN) {
    10141014                if (cmdp->cmdtype == CMDFUNCTION) {
    1015                         freefunc(cmdp->param.func);
     1015                        freefunc(psh, cmdp->param.func);
    10161016                }
    10171017                cmdp->cmdtype = entry->cmdtype;
    … …  
    10271027
    10281028void
    1029 defun(shinstance *psh,char *name, union node *func)
     1029defun(shinstance *psh, char *name, union node *func)
    10301030{
    10311031        struct cmdentry entry;
    … …  
    10331033        INTOFF;
    10341034        entry.cmdtype = CMDFUNCTION;
    1035         entry.u.func = copyfunc(func);
     1035        entry.u.func = copyfunc(psh, func);
    10361036        addcmdentry(psh, name, &entry);
    10371037        INTON;
    … …  
    10501050        if ((cmdp = cmdlookup(psh, name, 0)) != NULL &&
    10511051            cmdp->cmdtype == CMDFUNCTION) {
    1052                 freefunc(cmdp->param.func);
     1052                freefunc(psh, cmdp->param.func);
    10531053                delete_cmd_entry(psh);
    10541054                return (0);

  • trunk/src/kash/expand.c

    r1233 r2290  
    309309                        INTOFF;
    310310                        ifsp = psh->ifsfirst.next->next;
    311                         ckfree(psh->ifsfirst.next);
     311                        ckfree(psh, psh->ifsfirst.next);
    312312                        psh->ifsfirst.next = ifsp;
    313313                        INTON;
    … …  
    329329                INTOFF;
    330330                ifsp = psh->ifslastp->next->next;
    331                 ckfree(psh->ifslastp->next);
     331                ckfree(psh, psh->ifslastp->next);
    332332                psh->ifslastp->next = ifsp;
    333333                INTON;
    … …  
    463463                shfile_close(&psh->fdtab, in.fd);
    464464        if (in.buf)
    465                 ckfree(in.buf);
     465                ckfree(psh, in.buf);
    466466        if (in.jp)
    467467                psh->back_exitstatus = waitforjob(psh, in.jp);
    … …  
    922922                        return;
    923923                }
    924                 ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
     924                ifsp = (struct ifsregion *)ckmalloc(psh, sizeof (struct ifsregion));
    925925                psh->ifslastp->next = ifsp;
    926926        }
    … …  
    10451045                INTOFF;
    10461046                ifsp = psh->ifsfirst.next->next;
    1047                 ckfree(psh->ifsfirst.next);
     1047                ckfree(psh, psh->ifsfirst.next);
    10481048                psh->ifsfirst.next = ifsp;
    10491049                INTON;
    … …  
    10861086                if (psh->expdir == NULL) {
    10871087                        size_t i = strlen(str->text);
    1088                         psh->expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
     1088                        psh->expdir = ckmalloc(psh, i < 2048 ? 2048 : i); /* XXX */
    10891089                }
    10901090
    10911091                expmeta(psh, psh->expdir, str->text);
    1092                 ckfree(psh->expdir);
     1092                ckfree(psh, psh->expdir);
    10931093                psh->expdir = NULL;
    10941094                INTON;

  • trunk/src/kash/generated/init.c

    r1239 r2290  
    189189              psh->out2 = &psh->errout;
    190190              if (psh->memout.buf != NULL) {
    191                       ckfree(psh->memout.buf);
     191                      ckfree(psh, psh->memout.buf);
    192192                      psh->memout.buf = NULL;
    193193              }

  • trunk/src/kash/generated/nodes.c

    r1233 r2290  
    4949#include "machdep.h"
    5050#include "mystring.h"
     51#include "shinstance.h"
    5152
    5253
    … …  
    99100
    100101union node *
    101 copyfunc(n)
     102copyfunc(psh, n)
     103    struct shinstance *psh;
    102104        union node *n;
    103105{
    … …  
    107109        funcstringsize = 0;
    108110        calcsize(n);
    109         funcblock = ckmalloc(funcblocksize + funcstringsize);
     111        funcblock = ckmalloc(psh, funcblocksize + funcstringsize);
    110112        funcstring = (char *) funcblock + funcblocksize;
    111113        return copynode(n);
    … …  
    340342
    341343void
    342 freefunc(n)
     344freefunc(psh, n)
     345    shinstance *psh;
    343346        union node *n;
    344347{
    345348        if (n)
    346                 ckfree(n);
    347 }
     349                ckfree(psh, n);
     350}

  • trunk/src/kash/generated/nodes.h

    r1233 r2290  
    156156
    157157
    158 union node *copyfunc(union node *);
    159 void freefunc(union node *);
     158union node *copyfunc(struct shinstance *, union node *);
     159void freefunc(struct shinstance *, union node *);

  • trunk/src/kash/input.c

    r2288 r2290  
    343343/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
    344344        if (psh->parsefile->strpush) {
    345                 sp = ckmalloc(sizeof (struct strpush));
     345                sp = ckmalloc(psh, sizeof (struct strpush));
    346346                sp->prev = psh->parsefile->strpush;
    347347                psh->parsefile->strpush = sp;
    … …  
    373373        psh->parsefile->strpush = sp->prev;
    374374        if (sp != &(psh->parsefile->basestrpush))
    375                 ckfree(sp);
     375                ckfree(psh, sp);
    376376        INTON;
    377377}
    … …  
    415415        if (push) {
    416416                pushfile(psh);
    417                 psh->parsefile->buf = ckmalloc(BUFSIZ);
     417                psh->parsefile->buf = ckmalloc(psh, BUFSIZ);
    418418        }
    419419        if (psh->parsefile->fd > 0)
    … …  
    421421        psh->parsefile->fd = fd;
    422422        if (psh->parsefile->buf == NULL)
    423                 psh->parsefile->buf = ckmalloc(BUFSIZ);
     423                psh->parsefile->buf = ckmalloc(psh, BUFSIZ);
    424424        psh->parselleft = psh->parsenleft = 0;
    425425        psh->plinno = 1;
    … …  
    460460        psh->parsefile->nextc = psh->parsenextc;
    461461        psh->parsefile->linno = psh->plinno;
    462         pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
     462        pf = (struct parsefile *)ckmalloc(psh, sizeof (struct parsefile));
    463463        pf->prev = psh->parsefile;
    464464        pf->fd = -1;
    … …  
    478478                shfile_close(&psh->fdtab, pf->fd);
    479479        if (pf->buf)
    480                 ckfree(pf->buf);
     480                ckfree(psh, pf->buf);
    481481        while (pf->strpush)
    482482                popstring(psh);
    483483        psh->parsefile = pf->prev;
    484         ckfree(pf);
     484        ckfree(psh, pf);
    485485        psh->parsenleft = psh->parsefile->nleft;
    486486        psh->parselleft = psh->parsefile->lleft;

  • trunk/src/kash/jobs.c

    r1785 r2290  
    519519        INTOFF;
    520520        if (jp->ps != &jp->ps0) {
    521                 ckfree(jp->ps);
     521                ckfree(psh, jp->ps);
    522522                jp->ps = &jp->ps0;
    523523        }
    … …  
    723723                        INTOFF;
    724724                        if (psh->njobs == 0) {
    725                                 psh->jobtab = ckmalloc(4 * sizeof psh->jobtab[0]);
     725                                psh->jobtab = ckmalloc(psh, 4 * sizeof psh->jobtab[0]);
    726726                        } else {
    727                                 jp = ckmalloc((psh->njobs + 4) * sizeof psh->jobtab[0]);
     727                                jp = ckmalloc(psh, (psh->njobs + 4) * sizeof psh->jobtab[0]);
    728728                                memcpy(jp, psh->jobtab, psh->njobs * sizeof jp[0]);
    729729                                /* Relocate `ps' pointers */
    … …  
    731731                                        if (jp[i].ps == &psh->jobtab[i].ps0)
    732732                                                jp[i].ps = &jp[i].ps0;
    733                                 ckfree(psh->jobtab);
     733                                ckfree(psh, psh->jobtab);
    734734                                psh->jobtab = jp;
    735735                        }
    … …  
    752752#endif
    753753        if (nprocs > 1) {
    754                 jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
     754                jp->ps = ckmalloc(psh, nprocs * sizeof (struct procstat));
    755755        } else {
    756756                jp->ps = &jp->ps0;

  • trunk/src/kash/memalloc.c

    r1233 r2290  
    5656
    5757pointer
    58 ckmalloc(size_t nbytes)
     58ckmalloc(shinstance *psh, size_t nbytes)
    5959{
    6060        pointer p;
    6161
    62         p = malloc(nbytes);
     62        p = sh_malloc(psh, nbytes);
    6363        if (p == NULL)
    64                 error(NULL, "Out of space");
     64                error(psh, "Out of space");
    6565        return p;
    6666}
    … …  
    7272
    7373pointer
    74 ckrealloc(pointer p, size_t nbytes)
    75 {
    76         p = realloc(p, nbytes);
     74ckrealloc(struct shinstance *psh, pointer p, size_t nbytes)
     75{
     76        p = sh_realloc(psh, p, nbytes);
    7777        if (p == NULL)
    78                 error(NULL, "Out of space");
     78                error(psh, "Out of space");
    7979        return p;
    8080}
    … …  
    8686
    8787char *
    88 savestr(const char *s)
     88savestr(struct shinstance *psh, const char *s)
    8989{
    9090        char *p;
    91 
    92         p = ckmalloc(strlen(s) + 1);
    93         scopy(s, p);
     91    size_t len = strlen(s);
     92
     93        p = ckmalloc(psh, len + 1);
     94        memcpy(p, s, len + 1);
    9495        return p;
    9596}
    … …  
    134135                        blocksize = MINSIZE;
    135136                INTOFF;
    136                 sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
     137                sp = ckmalloc(psh, sizeof(struct stack_block) - MINSIZE + blocksize);
    137138                sp->prev = psh->stackp;
    138139                psh->stacknxt = sp->space;
    … …  
    182183                sp = psh->stackp;
    183184                psh->stackp = sp->prev;
    184                 ckfree(sp);
     185                ckfree(psh, sp);
    185186        }
    186187        psh->stacknxt = mark->stacknxt;
    … …  
    214215                sp = psh->stackp;
    215216                psh->stackp = sp->prev;
    216                 sp = ckrealloc((pointer)sp,
     217                sp = ckrealloc(psh, (pointer)sp,
    217218                    sizeof(struct stack_block) - MINSIZE + newlen);
    218219                sp->prev = psh->stackp;

  • trunk/src/kash/memalloc.h

    r1233 r2290  
    4848extern int herefd;*/
    4949
    50 pointer ckmalloc(size_t);
    51 pointer ckrealloc(pointer, size_t);
    52 char *savestr(const char *);
     50pointer ckmalloc(struct shinstance *, size_t);
     51pointer ckrealloc(struct shinstance *, pointer, size_t);
     52char *savestr(struct shinstance *, const char *);
    5353pointer stalloc(struct shinstance *, size_t);
    5454void stunalloc(struct shinstance *, pointer);
    … …  
    7575#define grabstackstr(psh, p)        stalloc((psh), stackblocksize(psh) - (psh)->sstrnleft)
    7676
    77 #define ckfree(p)       free((pointer)(p))
     77#define ckfree(psh, p)              sh_free(psh, (pointer)(p))

  • trunk/src/kash/miscbltin.c

    r1233 r2290  
    5959#include "mystring.h"
    6060#include "shinstance.h"
     61#include "shfile.h"
    6162
    6263#undef rflag
    … …  
    220221        }
    221222
    222         INTOFF;
    223         mask = umask(0);
    224         umask(mask);
    225         INTON;
     223        mask = shfile_get_umask(&psh->fdtab);
    226224
    227225        if ((ap = *psh->argptr) == NULL) {
    … …  
    268266                                mask = (mask << 3) + (*ap - '0');
    269267                        } while (*++ap != '\0');
    270                         umask(mask);
     268                        shfile_set_umask(&psh->fdtab, mask);
    271269                } else {
    272270                        void *set;
    … …  
    275273                        if ((set = bsd_setmode(psh, ap)) != 0) {
    276274                                mask = bsd_getmode(set, ~mask & 0777);
    277                                 ckfree(set);
     275                                ckfree(psh, set);
    278276                        }
    279277                        INTON;
    … …  
    281279                                error(psh, "Illegal mode: %s", ap);
    282280
    283                         umask(~mask & 0777);
     281                        shfile_set_umask(&psh->fdtab, ~mask & 0777);
    284282                }
    285283        }

  • trunk/src/kash/nodes.c.pat

    r1233 r2290  
    4545#include "machdep.h"
    4646#include "mystring.h"
     47#include "shinstance.h"
    4748
    4849
    … …  
    6869
    6970union node *
    70 copyfunc(n)
     71copyfunc(psh, n)
     72    struct shinstance *psh;
    7173        union node *n;
    7274{
    … …  
    7678        funcstringsize = 0;
    7779        calcsize(n);
    78         funcblock = ckmalloc(funcblocksize + funcstringsize);
     80        funcblock = ckmalloc(psh, funcblocksize + funcstringsize);
    7981        funcstring = (char *) funcblock + funcblocksize;
    8082        return copynode(n);
    … …  
    159161
    160162void
    161 freefunc(n)
     163freefunc(psh, n)
     164        shinstance *psh;
    162165        union node *n;
    163166{
    164167        if (n)
    165                 ckfree(n);
     168                ckfree(psh, n);
    166169}

  • trunk/src/kash/options.c

    r1238 r2290  
    280280        for (nparam = 0 ; argv[nparam] ; nparam++)
    281281                continue;
    282         ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
     282        ap = newparam = ckmalloc(psh, (nparam + 1) * sizeof *ap);
    283283        while (*argv) {
    284                 *ap++ = savestr(*argv++);
     284                *ap++ = savestr(psh, *argv++);
    285285        }
    286286        *ap = NULL;
    287         freeparam(&psh->shellparam);
     287        freeparam(psh, &psh->shellparam);
    288288        psh->shellparam.malloc = 1;
    289289        psh->shellparam.nparam = nparam;
    … …  
    298298
    299299void
    300 freeparam(volatile struct shparam *param)
     300freeparam(shinstance *psh, volatile struct shparam *param)
    301301{
    302302        char **ap;
    … …  
    304304        if (param->malloc) {
    305305                for (ap = param->p ; *ap ; ap++)
    306                         ckfree(*ap);
    307                 ckfree(param->p);
     306                        ckfree(psh, *ap);
     307                ckfree(psh, param->p);
    308308        }
    309309}
    … …  
    330330        for (ap1 = psh->shellparam.p ; --n >= 0 ; ap1++) {
    331331                if (psh->shellparam.malloc)
    332                         ckfree(*ap1);
     332                        ckfree(psh, *ap1);
    333333        }
    334334        ap2 = psh->shellparam.p;

  • trunk/src/kash/options.h

    r1233 r2290  
    133133void optschanged(struct shinstance *);
    134134void setparam(struct shinstance *, char **);
    135 void freeparam(volatile struct shparam *);
     135void freeparam(struct shinstance *, volatile struct shparam *);
    136136int shiftcmd(struct shinstance *, int, char **);
    137137int setcmd(struct shinstance *, int, char **);

  • trunk/src/kash/output.c

    r1784 r2290  
    8989        psh->out2 = &psh->errout;
    9090        if (psh->memout.buf != NULL) {
    91                 ckfree(psh->memout.buf);
     91                ckfree(psh, psh->memout.buf);
    9292                psh->memout.buf = NULL;
    9393        }
    … …  
    153153        } else if (dest->buf == NULL) {
    154154                INTOFF;
    155                 dest->buf = ckmalloc(dest->bufsize);
     155                dest->buf = ckmalloc(psh, dest->bufsize);
    156156                dest->nextc = dest->buf;
    157157                dest->nleft = dest->bufsize;
    … …  
    161161                INTOFF;
    162162                dest->bufsize <<= 1;
    163                 dest->buf = ckrealloc(dest->buf, dest->bufsize);
     163                dest->buf = ckrealloc(psh, dest->buf, dest->bufsize);
    164164                dest->nleft = dest->bufsize - offset;
    165165                dest->nextc = dest->buf + offset;
    … …  
    198198        INTOFF;
    199199        if (psh->output.buf) {
    200                 ckfree(psh->output.buf);
     200                ckfree(psh, psh->output.buf);
    201201                psh->output.buf = NULL;
    202202                psh->output.nleft = 0;

  • trunk/src/kash/parser.c

    r1236 r2290  
    11511151        psh->wordtext = out;
    11521152        if (dblquotep != NULL)
    1153             ckfree(dblquotep);
     1153            ckfree(psh, dblquotep);
    11541154        return psh->lasttoken = TWORD;
    11551155/* end of readtoken routine */
    … …  
    13471347                        varnest++;
    13481348                        if (varnest >= maxnest) {
    1349                                 dblquotep = ckrealloc(dblquotep, maxnest / 8);
     1349                                dblquotep = ckrealloc(psh, dblquotep, maxnest / 8);
    13501350                                dblquotep[(maxnest / 32) - 1] = 0;
    13511351                                maxnest += 32;
    … …  
    13801380        if (setjmp(jmploc.loc)) {
    13811381                if (str)
    1382                         ckfree(str);
     1382                        ckfree(psh, str);
    13831383                psh->parsebackquote = 0;
    13841384                psh->handler = savehandler;
    … …  
    13891389        savelen = (int)(out - stackblock(psh));
    13901390        if (savelen > 0) {
    1391                 str = ckmalloc(savelen);
     1391                str = ckmalloc(psh, savelen);
    13921392                memcpy(str, stackblock(psh), savelen);
    13931393        }
    … …  
    14951495                STADJUST(psh, savelen, out);
    14961496                INTOFF;
    1497                 ckfree(str);
     1497                ckfree(psh, str);
    14981498                str = NULL;
    14991499                INTON;

  • trunk/src/kash/redir.c

    r1233 r2290  
    117117                 * flags & REDIR_PUSH is never true if REDIR_VFORK is set.
    118118                 */
    119                 sv = ckmalloc(sizeof (struct redirtab));
     119                sv = ckmalloc(psh, sizeof (struct redirtab));
    120120                for (i = 0 ; i < 10 ; i++)
    121121                        sv->renamed[i] = EMPTY;
    … …  
    311311        INTOFF;
    312312        psh->redirlist = rp->next;
    313         ckfree(rp);
     313        ckfree(psh, rp);
    314314        INTON;
    315315}

  • trunk/src/kash/setmode.c

    r1233 r2290  
    167167                BITCMD *newset;                                         \
    168168                setlen += SET_LEN_INCR;                                 \
    169                 newset = realloc(saveset, sizeof(BITCMD) * setlen);     \
     169                newset = sh_realloc(NULL, saveset, sizeof(BITCMD) * setlen);    \
    170170                if (newset == NULL) {                                   \
    171                         free(saveset);                                  \
     171                        sh_free(NULL, saveset);                                 \
    172172                        return (NULL);                                  \
    173173                }                                                       \
    … …  
    202202        setlen = SET_LEN + 2;
    203203
    204         if ((set = malloc(sizeof(BITCMD) * setlen)) == NULL)
     204        if ((set = sh_malloc(NULL, sizeof(BITCMD) * setlen)) == NULL)
    205205                return (NULL);
    206206        saveset = set;
    … …  
    214214                perm = (mode_t)strtol(p, &ep, 8);
    215215                if (*ep || perm & ~(STANDARD_BITS|S_ISTXT)) {
    216                         free(saveset);
     216                        sh_free(NULL, saveset);
    217217                        return (NULL);
    218218                }
    … …  
    248248
    249249getop:          if ((op = *p++) != '+' && op != '-' && op != '=') {
    250                         free(saveset);
     250                        sh_free(NULL, saveset);
    251251                        return (NULL);
    252252                }

  • trunk/src/kash/shfile.c

    r2289 r2290  
    150150        while (new_size < fdMin)
    151151            new_size += SHFILE_GROW;
    152         new_tab = realloc(pfdtab->tab, new_size * sizeof(shfile));
     152        new_tab = sh_realloc(NULL, pfdtab->tab, new_size * sizeof(shfile));
    153153        if (new_tab)
    154154        {
    … …  
    230230}
    231231
    232 
    233232/**
    234233 * Constructs a path from the current directory and the passed in path.
    … …  
    257256#if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2
    258257        ||  *path == '\\'
    259         ||  (   !*path
     258        ||  (   *path
    260259             && path[1] == ':'
    261260             && (   (*path >= 'A' && *path <= 'Z')
    … …  
    10501049}
    10511050
     1051void shfile_set_umask(shfdtab *pfdtab, mode_t mask)
     1052{
     1053    (void)mask;
     1054}
     1055
    10521056
    10531057shdir *shfile_opendir(shfdtab *pfdtab, const char *dir)

  • trunk/src/kash/shfile.h

    r2289 r2290  
    150150#endif
    151151mode_t shfile_get_umask(shfdtab *);
     152void   shfile_set_umask(shfdtab *, mode_t);
    152153
    153154

  • trunk/src/kash/shinstance.c

    r2289 r2290  
    169169{
    170170    memset(psh, 0, sizeof(*psh));
    171     free(psh);
     171    sh_free(NULL, psh);
    172172}
    173173
    … …  
    190190
    191191   /* alloc clone array. */
    192    *dstp = dst = malloc(sizeof(*dst) * items + 1);
     192   *dstp = dst = sh_malloc(NULL, sizeof(*dst) * items + 1);
    193193   if (!dst)
    194194       return -1;
    … …  
    198198   while (items-- > 0)
    199199   {
    200        dst[items] = strdup(src[items]);
     200       dst[items] = sh_strdup(NULL, src[items]);
    201201       if (!dst[items])
    202202       {
    203203           /* allocation error, clean up. */
    204204           while (dst[++items])
    205                free(dst[items]);
    206            free(dst);
     205               sh_free(NULL, dst[items]);
     206           sh_free(NULL, dst);
    207207           errno = ENOMEM;
    208208           return -1;
    … …  
    231231     * The allocations.
    232232     */
    233     psh = calloc(sizeof(*psh), 1);
     233    psh = sh_calloc(NULL, sizeof(*psh), 1);
    234234    if (psh)
    235235    {
    … …  
    344344
    345345    return ret;
     346}
     347
     348/** malloc() */
     349void *sh_malloc(shinstance *psh, size_t size)
     350{
     351    (void)psh;
     352    return malloc(size);
     353}
     354
     355/** calloc() */
     356void *sh_calloc(shinstance *psh, size_t num, size_t size)
     357{
     358    (void)psh;
     359    return calloc(num, size);
     360}
     361
     362/** realloc() */
     363void *sh_realloc(shinstance *psh, void *old, size_t new_size)
     364{
     365    return realloc(old, new_size);
     366}
     367
     368/** strdup() */
     369char *sh_strdup(shinstance *psh, const char *string)
     370{
     371    size_t len = strlen(string);
     372    char *ret = sh_malloc(psh, len + 1);
     373    if (ret)
     374        memcpy(ret, string, len + 1);
     375    return ret;
     376}
     377
     378/** free() */
     379void sh_free(shinstance *psh, void *ptr)
     380{
     381    if (ptr)
     382        free(ptr);
     383    (void)psh;
    346384}
    347385

  • trunk/src/kash/shinstance.h

    r2287 r2290  
    335335char **sh_environ(shinstance *);
    336336const char *sh_gethomedir(shinstance *, const char *);
     337
     338/* heap */
     339void *sh_malloc(shinstance *, size_t);
     340void *sh_calloc(shinstance *, size_t, size_t);
     341void *sh_realloc(shinstance *, void *, size_t);
     342char *sh_strdup(shinstance *, const char *);
     343void  sh_free(shinstance *, void *);
    337344
    338345/* signals */

  • trunk/src/kash/tests/trap-exit-1

    r2288 r2290  
    11#!/bin/sh
    2 set -x
    32
    43trap 'echo "trap-exit-1: overriding exit 1"; exit 0' EXIT

  • trunk/src/kash/trap.c

    r1240 r2290  
    192192                INTOFF;
    193193                if (action)
    194                         action = savestr(action);
     194                        action = savestr(psh, action);
    195195
    196196                if (psh->trap[signo])
    197                         ckfree(psh->trap[signo]);
     197                        ckfree(psh, psh->trap[signo]);
    198198
    199199                psh->trap[signo] = action;
    … …  
    224224                        INTOFF;
    225225                        if (!vforked) {
    226                                 ckfree(*tp);
     226                                ckfree(psh, *tp);
    227227                                *tp = NULL;
    228228                        }

  • trunk/src/kash/var.c

    r1233 r2290  
    209209        struct var **vpp;
    210210#ifdef PC_OS2_LIBPATHS
    211         char *psz = ckmalloc(2048);
     211        char *psz = ckmalloc(psh, 2048);
    212212        int rc;
    213213        int i;
    … …  
    232232                        int cch1 = strlen(libpath_envs[i]);
    233233                        int cch2 = strlen(psz) + 1;
    234                         psh->libpath_vars[i].text = ckmalloc(cch1 + cch2);
     234                        psh->libpath_vars[i].text = ckmalloc(psh, cch1 + cch2);
    235235                        memcpy(psh->libpath_vars[i].text, libpath_envs[i], cch1);
    236236                        memcpy(psh->libpath_vars[i].text + cch1, psz, cch2);
    … …  
    246246                *vpp = &psh->libpath_vars[i];
    247247        }
    248         free(psz);
     248        ckfree(psh, psz);
    249249#endif
    250250
    … …  
    332332                len += strlen(val);
    333333        }
    334         d = nameeq = ckmalloc(len);
     334        d = nameeq = ckmalloc(psh, len);
    335335        q = name;
    336336        while (--namelen >= 0)
    … …  
    372372
    373373                if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
    374                         ckfree(vp->text);
     374                        ckfree(psh, vp->text);
    375375
    376376                vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
    … …  
    394394        if (flags & VNOSET)
    395395                return;
    396         vp = ckmalloc(sizeof (*vp));
     396        vp = ckmalloc(psh, sizeof (*vp));
    397397        vp->flags = flags & ~VNOFUNC;
    398398        vp->text = s;
    … …  
    416416        INTOFF;
    417417        for (lp = list ; lp ; lp = lp->next) {
    418                 setvareq(psh, savestr(lp->text), flags);
     418                setvareq(psh, savestr(psh, lp->text), flags);
    419419        }
    420420        INTON;
    … …  
    539539                                *prev = vp->next;
    540540                                if ((vp->flags & VTEXTFIXED) == 0)
    541                                         ckfree(vp->text);
     541                                        ckfree(psh, vp->text);
    542542                                if ((vp->flags & VSTRFIXED) == 0)
    543                                         ckfree(vp);
     543                                        ckfree(psh, vp);
    544544                        } else {
    545545                                if (vp->flags & VSTACK) {
    546                                         vp->text = savestr(vp->text);
     546                                        vp->text = savestr(psh, vp->text);
    547547                                        vp->flags &=~ VSTACK;
    548548                                }
    … …  
    618618        if (!list) {
    619619                list_len = 32;
    620                 list = ckmalloc(list_len * sizeof(*list));
     620                list = ckmalloc(psh, list_len * sizeof(*list));
    621621        }
    622622
    … …  
    628628                                continue;
    629629                        if (count >= list_len) {
    630                                 list = ckrealloc(list,
     630                                list = ckrealloc(psh, list,
    631631                                        (list_len << 1) * sizeof(*list));
    632632                                list_len <<= 1;
    … …  
    723723
    724724        INTOFF;
    725         lvp = ckmalloc(sizeof (struct localvar));
     725        lvp = ckmalloc(psh, sizeof (struct localvar));
    726726        if (name[0] == '-' && name[1] == '\0') {
    727727                char *p;
    728                 p = ckmalloc(sizeof_optlist);
     728                p = ckmalloc(psh, sizeof_optlist);
    729729                lvp->text = memcpy(p, psh->optlist, sizeof_optlist);
    730730                vp = NULL;
    … …  
    733733                if (vp == NULL) {
    734734                        if (strchr(name, '='))
    735                                 setvareq(psh, savestr(name), VSTRFIXED|flags);
     735                                setvareq(psh, savestr(psh, name), VSTRFIXED|flags);
    736736                        else
    737737                                setvar(psh, name, NULL, VSTRFIXED|flags);
    … …  
    744744                        vp->flags |= VSTRFIXED|VTEXTFIXED;
    745745                        if (name[vp->name_len] == '=')
    746                                 setvareq(psh, savestr(name), flags);
     746                                setvareq(psh, savestr(psh, name), flags);
    747747                }
    748748        }
    … …  
    770770                if (vp == NULL) {       /* $- saved */
    771771                        memcpy(psh->optlist, lvp->text, sizeof_optlist);
    772                         ckfree(lvp->text);
     772                        ckfree(psh, lvp->text);
    773773                } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
    774774                        (void)unsetvar(psh, vp->text, 0);
    … …  
    777777                                (*vp->func)(psh, lvp->text + vp->name_len + 1);
    778778                        if ((vp->flags & VTEXTFIXED) == 0)
    779                                 ckfree(vp->text);
     779                                ckfree(psh, vp->text);
    780780                        vp->flags = lvp->flags;
    781781                        vp->text = lvp->text;
    782782                }
    783                 ckfree(lvp);
     783                ckfree(psh, lvp);
    784784        }
    785785}
    … …  
    860860                if ((vp->flags & VSTRFIXED) == 0) {
    861861                        if ((vp->flags & VTEXTFIXED) == 0)
    862                                 ckfree(vp->text);
     862                                ckfree(psh, vp->text);
    863863                        *vpp = vp->next;
    864                         ckfree(vp);
     864                        ckfree(psh, vp);
    865865                }
    866866        }
Note: See TracChangeset for help on using the changeset viewer.

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