static void
fsclunk(Fid* fid)
{
Query* q;
File* f;
f = fid->file;
if(f == nil)
return;
q = f->aux;
if(q == nil)
return;
if(q->expr != nil){
/* the query was already made, destroy the file.
*
* We must incref the file because
* removefile assumes that we hold the
* reference given to it, and we do not.
* We just want the file removed from the tree.
*/
free(q->text);
freeexpr(q->expr);
free(q);
f->aux = nil;
incref(&f->ref);
removefile(f);
}
}
PyObject* get(const Value& ref) {
DataType type = ref.type();
switch(type) {
case DataType::Bool:
return incref(object(ref.get<bool>()).ptr());
case DataType::Float:
case DataType::Double:
return incref(object(ref.get<double>()).ptr());
case DataType::Char:
case DataType::Int8:
case DataType::Int16:
case DataType::Int32:
case DataType::Int64:
return incref(object(ref.get<int64_t>()).ptr());
case DataType::UInt8:
case DataType::UInt16:
case DataType::UInt32:
case DataType::UInt64:
return incref(object(ref.get<u_int64_t>()).ptr());
case DataType::String:
return incref(object(ref.get<std::string>()).ptr());
case DataType::Date:
case DataType::DateTime:
// TODO support for date
throw std::runtime_error("Wrong type");
case DataType::Nothing:
default:
Py_RETURN_NONE;
}
}
machine *make_machine()
{
machine *ret = NEW(machine);
ret->base_frame = make_frame(NULL,
make_table(),
make_table(), make_table(), NULL, PAUSE);
incref(ret->base_frame);
ret->current_frame = ret->base_frame;
incref(ret->current_frame);
ret->now = ret->base_frame;
incref(ret->now);
ret->accumulator = NULL;
ret->paused = 0;
ret->trace = make_stack_trace(arg("bottom-of-the-barrel"),
NULL,
NULL);
incref(ret->trace);
add_builtins(ret);
add_builtin_numbers(ret);
add_builtin_strings(ret);
add_builtin_files(ret);
return ret;
}
static Chan*
mouseopen(Chan *c, int omode)
{
switch((ulong)c->qid.path){
case Qdir:
if(omode != OREAD)
error(Eperm);
break;
case Qmouse:
lock(&mouse.ref.lk);
if(mouse.open){
unlock(&mouse.ref.lk);
error(Einuse);
}
mouse.open = 1;
mouse.ref.ref++;
mouse.lastresize = mouse.resize;
unlock(&mouse.ref.lk);
break;
case Qsnarf:
if(omode == ORDWR)
error(Eperm); /* one at a time please */
c->aux = nil;
incref(&mouse.ref);
break;
default:
incref(&mouse.ref);
}
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
return c;
}
Box* generatorThrow(Box* s, BoxedClass* exc_cls, Box* exc_val = nullptr, Box** args = nullptr) noexcept(S == CAPI) {
assert(s->cls == generator_cls);
BoxedGenerator* self = static_cast<BoxedGenerator*>(s);
if (self->iterated_from__hasnext__ && !self->entryExited)
Py_FatalError(".throw called on generator last advanced with __hasnext__");
Box* exc_tb = args ? args[0] : nullptr;
if (exc_tb && exc_tb != Py_None && !PyTraceBack_Check(exc_tb)) {
if (S == CAPI) {
PyErr_SetString(TypeError, "throw() third argument must be a traceback object");
return NULL;
}
raiseExcHelper(TypeError, "throw() third argument must be a traceback object");
}
if (!exc_val)
exc_val = Py_None;
if (!exc_tb)
exc_tb = Py_None;
ExcInfo exc_info = excInfoForRaise(incref(exc_cls), incref(exc_val), incref(exc_tb));
if (self->entryExited) {
if (S == CAPI) {
setCAPIException(exc_info);
return NULL;
}
throw exc_info;
}
self->exception = exc_info;
return generatorSend<S>(self, Py_None);
}
Box* setRemove(BoxedSet* self, Box* key) {
RELEASE_ASSERT(isSubclass(self->cls, set_cls), "");
if (PySet_Check(key)) {
try {
bool existed = _setRemove(self, key);
if (existed)
return incref(None);
} catch (ExcInfo e) {
if (!e.matches(TypeError))
throw e;
e.clear();
BoxedSet* tmpKey = makeNewSet(frozenset_cls, key);
AUTO_DECREF(tmpKey);
bool existed = _setRemove(self, tmpKey);
if (existed)
return incref(None);
}
raiseExcHelper(KeyError, key);
}
bool existed = _setRemove(self, key);
if (existed)
return incref(None);
raiseExcHelper(KeyError, key);
}
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);
}
template <ExceptionStyle S> Box* generatorClose(Box* s) noexcept(S == CAPI) {
assert(s->cls == generator_cls);
BoxedGenerator* self = static_cast<BoxedGenerator*>(s);
// check if the generator already exited
if (self->entryExited)
return incref(Py_None);
if (S == CAPI) {
Box* rtn = generatorThrow<S>(self, GeneratorExit, nullptr, nullptr);
if (rtn) {
PyErr_SetString(RuntimeError, "generator ignored GeneratorExit");
return NULL;
}
if (PyErr_ExceptionMatches(PyExc_StopIteration) || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
PyErr_Clear();
return incref(Py_None);
}
return NULL;
} else {
try {
autoDecref(generatorThrow<S>(self, GeneratorExit, nullptr, nullptr));
raiseExcHelper(RuntimeError, "generator ignored GeneratorExit");
} catch (ExcInfo e) {
if (e.matches(StopIteration) || e.matches(GeneratorExit)) {
e.clear();
return incref(Py_None);
}
throw e;
}
}
assert(0); // unreachable
}
frame *make_frame(frame * below,
table * scope,
table * scope_to_be,
table * scope_below, oyster * instruction, int flag)
{
frame *ret = NEW(frame);
ret->below = below;
incref(ret->below);
ret->scope = scope;
incref(ret->scope);
ret->scope_to_be = scope_to_be;
incref(ret->scope_to_be);
ret->scope_below = scope_below;
incref(scope_below);
ret->instruction = instruction;
incref(instruction);
ret->flag = flag;
return ret;
}
Box* setInit(Box* _self, Box* container, BoxedDict* kwargs) {
RELEASE_ASSERT(PySet_Check(_self), "");
if (PySet_Check(_self) && !_PyArg_NoKeywords("set()", kwargs)) {
throwCAPIException();
}
if (!container)
return incref(None);
BoxedSet* self = static_cast<BoxedSet*>(_self);
setClearInternal(self);
if (PyAnySet_Check(container)) {
for (auto&& elt : ((BoxedSet*)container)->s) {
self->s.insert(incref(elt));
}
} else if (PyDict_CheckExact(container)) {
for (auto&& elt : ((BoxedDict*)container)->d) {
self->s.insert(incref(elt.first));
}
} else {
for (auto elt : container->pyElements()) {
_setAddStolen(self, elt);
}
}
return incref(None);
}
static Box* propertyInit(Box* _self, Box* fget, Box* fset, Box** args) {
RELEASE_ASSERT(isSubclass(_self->cls, property_cls), "");
Box* fdel = args[0];
Box* doc = args[1];
BoxedProperty* self = static_cast<BoxedProperty*>(_self);
Box* prev_get = self->prop_get;
Box* prev_set = self->prop_set;
Box* prev_del = self->prop_del;
Box* prev_doc = self->prop_doc;
self->prop_get = fget == Py_None ? NULL : incref(fget);
self->prop_set = fset == Py_None ? NULL : incref(fset);
self->prop_del = fdel == Py_None ? NULL : incref(fdel);
self->prop_doc = xincref(doc);
self->getter_doc = false;
Py_XDECREF(prev_get);
Py_XDECREF(prev_set);
Py_XDECREF(prev_del);
Py_XDECREF(prev_doc);
/* if no docstring given and the getter has one, use that one */
if ((doc == NULL || doc == Py_None) && fget != NULL) {
propertyDocCopy(self, fget);
}
return incref(Py_None);
}
static File*
walkfile1(File *dir, char *elem)
{
File *fp;
Filelist *fl;
rlock(&dir->RWLock);
if(strcmp(elem, "..") == 0){
fp = dir->parent;
incref(&fp->Ref);
runlock(&dir->RWLock);
closefile(dir);
return fp;
}
fp = nil;
for(fl=dir->filelist; fl; fl=fl->link)
if(fl->f && strcmp(fl->f->Dir.name, elem)==0){
fp = fl->f;
incref(&fp->Ref);
break;
}
runlock(&dir->RWLock);
closefile(dir);
return fp;
}
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();
}
static Box* staticmethodInit(Box* _self, Box* f) {
RELEASE_ASSERT(isSubclass(_self->cls, staticmethod_cls), "");
BoxedStaticmethod* self = static_cast<BoxedStaticmethod*>(_self);
Py_CLEAR(self->sm_callable);
self->sm_callable = incref(f);
return incref(Py_None);
}
void
kproc(char *name, void (*func)(void*), void *arg, int flags)
{
Proc *p;
Pgrp *pg;
Fgrp *fg;
Egrp *eg;
int pid;
void *tos;
p = newproc();
if(flags & KPDUPPG) {
pg = up->env->pgrp;
incref(&pg->r);
p->env->pgrp = pg;
}
if(flags & KPDUPFDG) {
fg = up->env->fgrp;
incref(&fg->r);
p->env->fgrp = fg;
}
if(flags & KPDUPENVG) {
eg = up->env->egrp;
incref(&eg->r);
p->env->egrp = eg;
}
p->env->uid = up->env->uid;
p->env->gid = up->env->gid;
kstrdup(&p->env->user, up->env->user);
strcpy(p->text, name);
p->func = func;
p->arg = arg;
lock(&procs.l);
if(procs.tail != nil) {
p->prev = procs.tail;
procs.tail->next = p;
}
else {
procs.head = p;
p->prev = nil;
}
procs.tail = p;
unlock(&procs.l);
if(flags & KPX11){
p->kstack = nil; /* never freed; also up not defined */
tos = (char*)mallocz(X11STACK, 0) + X11STACK - sizeof(void*);
}else
p->kstack = stackalloc(p, &tos);
pid = rfork_thread(RFPROC|RFMEM|RFNOWAIT, tos, tramp, p);
if(pid < 0)
panic("rfork");
}
BoxedSysFlags() {
auto zero = boxInt(0);
assert(zero);
division_warning = incref(zero);
bytes_warning = incref(zero);
no_user_site = incref(zero);
optimize = incref(zero);
Py_DECREF(zero);
}
// Constructor for statically allocated objects+
// (Please never use it for dynamically allocated objects with *myobj)
Ref(T& apnt) noexcept:pnt(&apnt)
{
if(!apnt.__refcountdata.refered)
{
apnt.__refcountdata.refered=true;
incref();
}
incref();
}
Box* setIAnd(BoxedSet* lhs, BoxedSet* rhs) {
RELEASE_ASSERT(PyAnySet_Check(lhs), "");
if (!PyAnySet_Check(rhs))
return incref(NotImplemented);
auto r = setIntersectionUpdate2(lhs, rhs);
Py_DECREF(r);
return incref(lhs);
}
Box* setIXor(BoxedSet* lhs, BoxedSet* rhs) {
RELEASE_ASSERT(PyAnySet_Check(lhs), "");
if (!PyAnySet_Check(rhs))
return incref(NotImplemented);
_setSymmetricDifferenceUpdate(lhs, rhs);
return incref(lhs);
}
static Box* classmethodInit(Box* _self, Box* f) {
RELEASE_ASSERT(isSubclass(_self->cls, classmethod_cls), "");
BoxedClassmethod* self = static_cast<BoxedClassmethod*>(_self);
Box* prev = self->cm_callable;
self->cm_callable = incref(f);
Py_XDECREF(prev);
return incref(Py_None);
}
void
kproc(char *name, void (*func)(void*), void *arg, int flags)
{
DWORD h;
Proc *p;
Pgrp *pg;
Fgrp *fg;
Egrp *eg;
p = newproc();
if(p == nil)
panic("out of kernel processes");
p->os = CreateEvent(NULL, FALSE, FALSE, NULL);
if(p->os == NULL)
panic("can't allocate os event");
if(flags & KPDUPPG) {
pg = up->env->pgrp;
incref(&pg->r);
p->env->pgrp = pg;
}
if(flags & KPDUPFDG) {
fg = up->env->fgrp;
incref(&fg->r);
p->env->fgrp = fg;
}
if(flags & KPDUPENVG) {
eg = up->env->egrp;
incref(&eg->r);
p->env->egrp = eg;
}
p->env->ui = up->env->ui;
kstrdup(&p->env->user, up->env->user);
strcpy(p->text, name);
p->func = func;
p->arg = arg;
lock(&procs.l);
if(procs.tail != nil) {
p->prev = procs.tail;
procs.tail->next = p;
}
else {
procs.head = p;
p->prev = nil;
}
procs.tail = p;
unlock(&procs.l);
p->pid = (int)CreateThread(0, 16384, tramp, p, 0, &h);
if(p->pid <= 0)
panic("ran out of kernel processes");
}
Chan*
consopen(Chan *c, int omode)
{
c = devopen(c, omode, contab, nelem(contab), devgen);
switch((ulong)c->qid.path) {
case Qconsctl:
incref(&kbd.ctl);
break;
case Qpointer:
if(incref(&kbd.ptr) != 1){
decref(&kbd.ptr);
c->flag &= ~COPEN;
error(Einuse);
}
break;
case Qscancode:
qlock(&kbd.gq);
if(gkscanq || !gkscanid) {
qunlock(&kbd.q);
c->flag &= ~COPEN;
if(gkscanq)
error(Einuse);
else
error(Ebadarg);
}
gkscanq = qopen(256, 0, nil, nil);
qunlock(&kbd.gq);
break;
case Qkprint:
wlock(&kprintq.l);
if(kprintq.q != nil){
wunlock(&kprintq.l);
c->flag &= ~COPEN;
error(Einuse);
}
kprintq.q = qopen(32*1024, 0, 0, 0);
if(kprintq.q == nil){
wunlock(&kprintq.l);
c->flag &= ~COPEN;
error(Enomem);
}
qnoblock(kprintq.q, 1);
wunlock(&kprintq.l);
break;
case Qsnarf:
if(omode == ORDWR)
error(Eperm);
if(omode == OREAD)
c->aux = strdup("");
else
c->aux = mallocz(SnarfSize, 1);
break;
}
return c;
}
Box* setIOr(BoxedSet* lhs, BoxedSet* rhs) {
RELEASE_ASSERT(PyAnySet_Check(lhs), "");
if (!PyAnySet_Check(rhs))
return incref(NotImplemented);
// TODO just [write and] call setUnionUpdate2
for (auto&& elt : rhs->s) {
_setAdd(lhs, elt);
}
return incref(lhs);
}
Box* setISub(BoxedSet* lhs, BoxedSet* rhs) {
RELEASE_ASSERT(PyAnySet_Check(lhs), "");
if (!PyAnySet_Check(rhs))
return incref(NotImplemented);
// TODO: write and call setDifferenceUpdate2
for (auto&& elt : rhs->s) {
_setRemove(lhs, elt);
}
return incref(lhs);
}
static BORROWED(Box*) back(Box* obj, void*) noexcept {
auto f = static_cast<BoxedFrame*>(obj);
if (!f->_back) {
if (!f->frame_info->back)
f->_back = incref(None);
else
f->_back = incref(BoxedFrame::boxFrame(f->frame_info->back));
}
return f->_back;
}
void
kproc(char *name, void (*func)(void *), void *arg)
{
Mach *m = machp();
Proc *p;
static Pgrp *kpgrp;
p = newproc();
p->psstate = 0;
p->procmode = 0640;
p->kp = 1;
p->noswap = 1;
p->scallnr = m->externup->scallnr;
memmove(p->arg, m->externup->arg, sizeof(m->externup->arg));
p->nerrlab = 0;
p->slash = m->externup->slash;
p->dot = m->externup->dot;
if(p->dot)
incref(p->dot);
memmove(p->note, m->externup->note, sizeof(p->note));
p->nnote = m->externup->nnote;
p->notified = 0;
p->lastnote = m->externup->lastnote;
p->notify = m->externup->notify;
p->ureg = 0;
p->dbgreg = 0;
procpriority(p, PriKproc, 0);
kprocchild(p, func, arg);
kstrdup(&p->user, eve);
kstrdup(&p->text, name);
if(kpgrp == 0)
kpgrp = newpgrp();
p->pgrp = kpgrp;
incref(kpgrp);
memset(p->time, 0, sizeof(p->time));
p->time[TReal] = sys->ticks;
ready(p);
/*
* since the bss/data segments are now shareable,
* any mmu info about this process is now stale
* and has to be discarded.
*/
p->newtlb = 1;
mmuflush();
}
Reffont*
rfget(int fix, int save, int setfont, char *name)
{
Reffont *r;
Font *f;
int i;
r = nil;
if(name == nil){
name = fontnames[fix];
r = reffonts[fix];
}
if(r == nil){
for(i=0; i<nfontcache; i++)
if(strcmp(name, fontcache[i]->f->name) == 0){
r = fontcache[i];
goto Found;
}
f = openfont(display, name);
if(f == nil){
warning(nil, "can't open font file %s: %r\n", name);
return nil;
}
r = emalloc(sizeof(Reffont));
r->f = f;
fontcache = erealloc(fontcache, (nfontcache+1)*sizeof(Reffont*));
fontcache[nfontcache++] = r;
}
Found:
if(save){
incref(&r->ref);
if(reffonts[fix])
rfclose(reffonts[fix]);
reffonts[fix] = r;
if(name != fontnames[fix]){
free(fontnames[fix]);
fontnames[fix] = estrdup(name);
}
}
if(setfont){
reffont.f = r->f;
incref(&r->ref);
rfclose(reffonts[0]);
font = r->f;
reffonts[0] = r;
incref(&r->ref);
iconinit();
}
incref(&r->ref);
return r;
}
static BORROWED(Box*) globals(Box* obj, void*) noexcept {
auto f = static_cast<BoxedFrame*>(obj);
if (!f->_globals) {
Box* globals = f->frame_info->globals;
if (globals && PyModule_Check(globals))
f->_globals = incref(globals->getAttrWrapper());
else {
f->_globals = incref(globals);
}
}
return f->_globals;
}
void
loadimages(Page *p)
{
Cimage *ci;
Iimage *i;
Rune *src;
addrefresh(p, "loading images...");
reverseimages(&p->doc->images);
for(i=p->doc->images; i!=nil; i=i->nextimage){
if(p->aborting)
break;
src = urlcombine(getbase(p), i->imsrc);
ci = findimg(src);
if(ci == nil){
ci = loadimg(src, i->imwidth, i->imheight);
qlock(&cimagelock);
ci->next = cimages;
cimages = ci;
qunlock(&cimagelock);
}
free(src);
incref(ci);
i->aux = ci;
p->cimage = erealloc(p->cimage, ++p->ncimage*sizeof(Cimage *));
p->cimage[p->ncimage-1] = ci;
p->changed = TRUE;
addrefresh(p, "");
}
}
/*
* called by segattach()
*/
static Segment*
globalsegattach(Proc *p, char *name)
{
int x;
Globalseg *g;
Segment *s;
g = nil;
if(waserror()){
unlock(&globalseglock);
nexterror();
}
lock(&globalseglock);
for(x = 0; x < nelem(globalseg); x++){
g = globalseg[x];
if(g != nil && strcmp(g->name, name) == 0)
break;
}
if(x == nelem(globalseg)){
unlock(&globalseglock);
poperror();
return nil;
}
devpermcheck(g->uid, g->perm, ORDWR);
s = g->s;
if(s == nil)
error("global segment not assigned a virtual address");
if(isoverlap(p, s->base, s->top - s->base) != nil)
error("overlaps existing segment");
incref(s);
unlock(&globalseglock);
poperror();
return s;
}
