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);
}
