void push_instruction_list(machine * m, oyster * ins, table * scope, table * scope_below) { incref(ins); frame *top = NULL; frame **cur = ⊤ while (!nilp(ins)) { (*cur) = make_frame(NULL, scope, NULL, scope_below, car(ins), EVALUATE); incref(*cur); cur = &((*cur)->below); oyster *ins2 = cdr(ins); incref(ins2); decref(ins); ins = ins2; } decref(ins); (*cur) = m->current_frame; m->current_frame = top; }
static long extrarw(int write, Chan *c, void *a, long n, vlong off) { int i; SDrw *f; SDev *sdev; SDunit *unit; sdev = sdgetdev(DEV(c->qid)); if(sdev == nil) error(Enonexist); if(waserror()){ decref(&sdev->r); nexterror(); } unit = sdev->unit[UNIT(c->qid)]; if(unit->vers != c->qid.vers) error(Echange); unit = sdev->unit[UNIT(c->qid)]; i = PART(c->qid); if(i >= unit->nefile) error(Enonexist); f = unit->efile[i].r; if(write) f = unit->efile[i].w; if(i >= unit->nefile || f == nil) error(Eperm); n = f(unit, c, a, n, off); poperror(); decref(&sdev->r); return n; }
void stack_trace_free(stack_trace *t) { decref(t->function); decref(t->remove_when); decref(t->below); free(t); }
int main (int argc, char *argv[]) { big_pyobj *f, *freevars; int i; /** * test1: simple closure with no free vars * f = lambda x: x * decref(list) */ pymem_init(); freevars = create_list(inject_int(0)); incref(freevars); f = create_closure(dummy_function, inject_big(freevars)); incref(f); assert (freevars->ref_ctr == 2); decref(f); assert (freevars->ref_ctr == 1); decref(freevars); pymem_print_stats(); pymem_shutdown(); }
void consclose(Chan *c) { if((c->flag & COPEN) == 0) return; switch((ulong)c->qid.path) { case Qconsctl: if(decref(&kbd.ctl) == 0) kbd.raw = 0; break; case Qpointer: decref(&kbd.ptr); break; case Qscancode: qlock(&kbd.gq); if(gkscanq) { qfree(gkscanq); gkscanq = 0; } qunlock(&kbd.gq); break; case Qkprint: wlock(&kprintq.l); qfree(kprintq.q); kprintq.q = nil; wunlock(&kprintq.l); break; case Qsnarf: if(c->mode == OWRITE) clipwrite(c->aux, strlen(c->aux)); free(c->aux); break; } }
static Chan* sdattach(char* spec) { Chan *c; char *p; SDev *sdev; int idno, subno; if(*spec == '\0'){ c = devattach(sddevtab.dc, spec); mkqid(&c->qid, QID(0, 0, 0, Qtopdir), 0, QTDIR); return c; } if(spec[0] != 's' || spec[1] != 'd') error(Ebadspec); idno = spec[2]; subno = strtol(&spec[3], &p, 0); if(p == &spec[3]) error(Ebadspec); if((sdev=sdgetdev(idno)) == nil) error(Enonexist); if(sdgetunit(sdev, subno) == nil){ decref(&sdev->r); error(Enonexist); } c = devattach(sddevtab.dc, spec); mkqid(&c->qid, QID(sdev->idno, subno, 0, Qunitdir), 0, QTDIR); c->dev = (sdev->idno << UnitLOG) + subno; decref(&sdev->r); return c; }
static int sdwstat(Chan* c, uchar* dp, int n) { Dir *d; SDpart *pp; SDperm *perm; SDunit *unit; SDev *sdev; if(c->qid.type & QTDIR) error(Eperm); sdev = sdgetdev(DEV(c->qid)); if(sdev == nil) error(Enonexist); unit = sdev->unit[UNIT(c->qid)]; qlock(&unit->ctl); d = nil; if(waserror()){ free(d); qunlock(&unit->ctl); decref(&sdev->r); nexterror(); } switch(TYPE(c->qid)){ default: error(Eperm); case Qctl: perm = &unit->ctlperm; break; case Qraw: perm = &unit->rawperm; break; case Qpart: pp = &unit->part[PART(c->qid)]; if(unit->vers+pp->vers != c->qid.vers) error(Enonexist); perm = &pp->SDperm; break; } if(strcmp(up->env->user, perm->user) && !iseve()) error(Eperm); d = smalloc(sizeof(Dir)+n); n = convM2D(dp, n, &d[0], (char*)&d[1]); if(n == 0) error(Eshortstat); if(!emptystr(d[0].uid)) kstrdup(&perm->user, d[0].uid); if(d[0].mode != ~0UL) perm->perm = (perm->perm & ~0777) | (d[0].mode & 0777); free(d); qunlock(&unit->ctl); decref(&sdev->r); poperror(); return n; }
static void pass1(int pass, volatile Diag *dp) { int i; if(m->machno == 0) iprint(" %d", pass); for (i = 1000*1000; --i > 0; ) { incref(&dp->cnt); incref(&dp->cnt); } synccpus(&dp->sync, navailcpus); /* all cpus are now here */ ilock(dp); if(dp->cnt.ref != 0) panic("cpu%d: diag: failed w count %ld", m->machno, dp->cnt.ref); iunlock(dp); synccpus(&dp->sync, 2 * navailcpus); /* all cpus are now here */ decref(&dp->sync); decref(&dp->sync); }
int is_match_pike(struct Prog* prog,char* input, char** subp) { char* sp; struct Sub* sub; struct Inst* pc; int matched = 0; struct ThreadList *clist, *nlist, *tlist; int len = prog->len; clist = threadlist(len); nlist = threadlist(len); gen++; sub = newsub(); int i; for(i = 0; i < MAXSUB; i++) sub->sub[i] = NULL; addthread(clist, thread(prog->start, sub), input); for(sp = input; ; sp++) { if(clist->n == 0) break; gen++; for(i = 0; i < clist->n; i++) { pc = clist->t[i].pc; sub = clist->t[i].sub; switch(pc->opcode) { case Char: if(*sp != pc->c) { decref(sub); break; } //printf("%c", pc->c); case Any: if(*sp == '\0') { decref(sub); break; } addthread(nlist, thread(pc+1, sub), sp+1); break; case Match: matched = 1; int i; for(i = 0; i < MAXSUB; i++) subp[i] = sub->sub[i]; for(i = 0; i < clist->n; i++) decref(clist->t[i].sub); goto BreakFor; } } //printf("\n"); BreakFor: tlist = clist; clist = nlist; nlist = tlist; nlist->n = 0; if(sp == '\0') break; } if(matched) return sp - input; return 0; }
void machine_free(machine * x) { decref(x->base_frame); decref(x->current_frame); decref(x->now); decref(x->accumulator); free(x); }
void frame_free(frame * x) { decref(x->below); decref(x->scope); decref(x->scope_to_be); decref(x->scope_below); decref(x->instruction); free(x); }
void cleanup(void) { if(P == nil) return; remproc(P); decref(&nproc); freesegs(); fddecref(P->fd); if(P->path != nil && decref(P->path) == 0) free(P->path); free(P); }
static Chan* sdopen(Chan* c, int omode) { SDpart *pp; SDunit *unit; SDev *sdev; uchar tp; c = devopen(c, omode, 0, 0, sdgen); if((tp = TYPE(c->qid)) != Qctl && tp != Qraw && tp != Qpart) return c; sdev = sdgetdev(DEV(c->qid)); if(sdev == nil) error(Enonexist); unit = sdev->unit[UNIT(c->qid)]; switch(TYPE(c->qid)){ case Qctl: c->qid.vers = unit->vers; break; case Qraw: c->qid.vers = unit->vers; if(tas(&unit->rawinuse) != 0){ c->flag &= ~COPEN; decref(&sdev->r); error(Einuse); } unit->state = Rawcmd; break; case Qpart: qlock(&unit->ctl); if(waserror()){ qunlock(&unit->ctl); c->flag &= ~COPEN; decref(&sdev->r); nexterror(); } pp = &unit->part[PART(c->qid)]; c->qid.vers = unit->vers+pp->vers; qunlock(&unit->ctl); poperror(); break; } decref(&sdev->r); return c; }
void winclose(Win *w) { if(w->f == nil){ cmdprint("?\n"); return; } if(!decref(w->f)){ if(w->f->change > 0){ cmdprint("?\n"); incref(w->f); w->f->change = -1; return; } putfil(w->f); w->f = nil; } freeimage(w->im); if(w->f != nil){ w->wnext->wprev = w->wprev; w->wprev->wnext = w->wnext; } w->next->prev = w->prev; w->prev->next = w->next; if(w == actw) actw = nil; if(w == actf) actf = nil; free(w); }
void closepgrp(Pgrp *p) { Mhead **h, **e, *f, *next; if(decref(&p->ref) != 0) return; qlock(&p->debug); wlock(&p->ns); p->pgrpid = -1; e = &p->mnthash[MNTHASH]; for(h = p->mnthash; h < e; h++) { for(f = *h; f; f = next) { wlock(&f->lock); cclose(f->from); mountfree(f->mount); f->mount = nil; next = f->hash; wunlock(&f->lock); putmhead(f); } } wunlock(&p->ns); qunlock(&p->debug); free(p); }
static void consclose(Chan *c) { if((c->flag & COPEN) == 0) return; switch((ulong)c->qid.path) { case Qconsctl: /* last close of control file turns off raw */ if(decref(&kbd.ctl) == 0) kbd.raw = 0; break; case Qscancode: qlock(&kbd.gq); if(gkscanq) { qfree(gkscanq); gkscanq = nil; } qunlock(&kbd.gq); break; case Qkprint: wlock(&kprintq.l); qfree(kprintq.q); kprintq.q = nil; wunlock(&kprintq.l); break; } }
void pgfree(Page* pg) { decref(&pga.pgsza[pg->pgszi].npages); physfree(pg->pa, sys->pgsz[pg->pgszi]); free(pg); }
int main(int argc, char *argv[]) { init_oyster(); FILE *file; int print; if (argc == 1) { file = stdin; print = 1; } else { file = fopen(argv[1], "r"); print = 0; } if (errno) { error(errno, errno, "File error"); } /// g'damn g_scanner won't return a token until EOF is reached. /// all my trickery is for naught. oyster *ret = evaluate_file(file, print); decref(ret); clean_up_oyster(); return 0; }
void set_accumulator(machine * m, oyster * value) { oyster *t = m->accumulator; m->accumulator = value; incref(m->accumulator); decref(t); }
void ipclose(Chan *c) { Conv *cc; switch(TYPE(c->qid)) { case Qcs: csclose(c); break; case Qdata: case Qctl: if((c->flag & COPEN) == 0) break; cc = proto[PROTO(c->qid)].conv[CONV(c->qid)]; if(decref(&cc->r) != 0) break; strcpy(cc->owner, "network"); cc->perm = 0666; cc->state = "Closed"; cc->laddr = 0; cc->raddr = 0; cc->lport = 0; cc->rport = 0; close(cc->sfd); break; } }
static void ipclose(Chan* c) { Fs *f; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: break; case Qlog: if(c->flag & COPEN) netlogclose(f); break; case Qdata: case Qctl: case Qerr: if(c->flag & COPEN) closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]); break; case Qsnoop: if(c->flag & COPEN) decref(&f->p[PROTO(c->qid)]->conv[CONV(c->qid)]->snoopers); break; } free(((IPaux*)c->aux)->owner); free(c->aux); }
static void devlogfsclose(Chan *c) { int instance, qid, qt; #ifdef CALLTRACE print("devlogfsclose(c = 0x%.8lux)\n", (ulong)c); #endif SPLITPATH(c->qid.path, c->qid.type, instance, qid, qt); USED(instance); if(DATAQID(qid, qt) && (c->flag & COPEN) != 0) { Devlogfs *d; d = c->aux; qlock(&d->qlock); if (qid == Qfs && d->state == Attached) { logfsserverflush(d->server); logfsserverfree(&d->server); d->state = BootOpen; } qunlock(&d->qlock); decref(&d->ref); } #ifdef CALLTRACE print("devlogfsclose(c = 0x%.8lux) - return\n", (ulong)c); #endif }
Message& operator=(const Message& other) { decref(); data_ = other.data_; data_->refs++; return *this; }
/* called while row is locked */ void flushrefresh(void) { Refresh *r, *next; Page *p; qlock(&refreshlock); for(r=refreshs; r!=nil; r=next) { p = r->p; if(p->changed==TRUE && p->aborting==FALSE) { p->changed = FALSE; if(p->parent==nil || p->loading==FALSE) pagerender(p); if(!p->refresh.t) pagesetrefresh(p); } if(p->status) { winsetstatus(p->w, p->status); free(p->status); p->status = nil; } winseturl(p->w); winsettag(p->w); decref(p->w); next = r->next; free(r); } refreshs = nil; qunlock(&refreshlock); }
void closedev(Dev *d) { int i; Usbdev *ud; if(d==nil || decref(d) != 0) return; dprint(2, "%s: closedev %#p %s\n", argv0, d, d->dir); if(d->free != nil) d->free(d->aux); if(d->cfd >= 0) close(d->cfd); if(d->dfd >= 0) close(d->dfd); d->cfd = d->dfd = -1; free(d->dir); d->dir = nil; ud = d->usb; d->usb = nil; if(ud != nil){ free(ud->vendor); free(ud->product); free(ud->serial); for(i = 0; i < nelem(ud->ep); i++) free(ud->ep[i]); for(i = 0; i < nelem(ud->ddesc); i++) free(ud->ddesc[i]); for(i = 0; i < nelem(ud->conf); i++) closeconf(ud->conf[i]); free(ud); } free(d); }
void string_reset(caValue* val) { StringData* data = (StringData*) val->value_data.ptr; if (data != NULL) decref(data); val->value_data.ptr = NULL; }
void test_filter() { Value a = range(0, 10); Value filtered = filter(a, is_even); expect_str(filtered, "[0, 2, 4, 6, 8]"); decref(filtered); }
void string_resize(StringData** data, int newLength) { if (*data == NULL) { *data = string_create(newLength); return; } // Perform the same check as touch() if ((*data)->refCount == 1) { INCREMENT_STAT(StringResizeInPlace); // Modify in-place *data = (StringData*) realloc(*data, sizeof(StringData) + newLength + 1); (*data)->length = newLength; return; } INCREMENT_STAT(StringResizeCreate); StringData* oldData = *data; StringData* newData = string_create(newLength); memcpy(newData->str, oldData->str, oldData->length + 1); decref(oldData); *data = newData; }
static void freecimage(Cimage *ci) { Cimage *ci1; qlock(&cimagelock); if(decref(ci) == 0){ if(ci->i) freeimage(ci->i); else if(ci->mi) freememimage(ci->mi); urlfree(ci->url); ci1 = cimages; if(ci1 == ci) cimages = ci->next; else{ while(ci1){ if(ci1->next == ci){ ci1->next = ci->next; break; } ci1 = ci1->next; } } free(ci); } qunlock(&cimagelock); }
void test_lisp_parse_1() { Value parsed = parse(blob_s("(test 1 2 3)")); expect_str(nth(parsed, 0), ":test"); expect(nth(parsed, 1).raw == int_value(1).raw); expect_str(parsed, "[:test, 1, 2, 3]"); decref(parsed); }