static void atomic (lua_State *L) {
global_State *g = G(L);
GCObject *origweak, *origall;
lua_assert(!iswhite(obj2gco(g->mainthread)));
markobject(g, L); /* mark running thread */
/* registry and global metatables may be changed by API */
markvalue(g, &g->l_registry);
markmt(g); /* mark basic metatables */
/* remark occasional upvalues of (maybe) dead threads */
remarkupvals(g);
/* traverse objects caught by write barrier and by 'remarkupvals' */
retraversegrays(g);
convergeephemerons(g);
/* at this point, all strongly accessible objects are marked. */
/* clear values from weak tables, before checking finalizers */
clearvalues(g->weak, NULL);
clearvalues(g->allweak, NULL);
origweak = g->weak; origall = g->allweak;
separatetobefnz(L, 0); /* separate objects to be finalized */
markbeingfnz(g); /* mark userdata that will be finalized */
propagateall(g); /* remark, to propagate `preserveness' */
convergeephemerons(g);
/* at this point, all resurrected objects are marked. */
/* remove dead objects from weak tables */
clearkeys(g->ephemeron, NULL); /* clear keys from all ephemeron tables */
clearkeys(g->allweak, NULL); /* clear keys from all allweak tables */
/* clear values from resurrected weak tables */
clearvalues(g->weak, origweak);
clearvalues(g->allweak, origall);
g->sweepstrgc = 0; /* prepare to sweep strings */
g->gcstate = GCSsweepstring;
g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
/*lua_checkmemory(L);*/
}
void os_inputclose(usbdevice* kb){
if(kb->event){
clearkeys(kb);
IOServiceClose(kb->event);
kb->event = 0;
}
}
int inputopen(usbdevice* kb){
// Open master port (if not done yet)
static mach_port_t master = 0;
kern_return_t res;
if(!master&& (res = IOMasterPort(bootstrap_port, &master)) != KERN_SUCCESS){
master = 0;
printf("Unable to open master port: 0x%08x\n", res);
return 0;
}
// Open an HID service
io_iterator_t iter;
if((res = IOServiceGetMatchingServices(master, IOServiceMatching(kIOHIDSystemClass), &iter)) != KERN_SUCCESS){
printf("Unable to get input service iterator: 0x%08x\n", res);
return 0;
}
if((res = IOServiceOpen(IOIteratorNext(iter), mach_task_self(), kIOHIDParamConnectType, &kb->event)) != KERN_SUCCESS){
IOObjectRelease(iter);
printf("Unable to open IO service: 0x%08x\n", res);
kb->event = 0;
return 0;
}
IOObjectRelease(iter);
clearkeys(kb);
return 1;
}
/*
** PR_INTEGRITY -- print out integrity constraints on a relation
**
** Finds all integrity tuples for this unique relation, and
** calls pr_int() to print a query from them.
**
** Parameters:
** relid -- rel name
** relowner -- 2 byte owner id
**
** Returns:
** none
**
** Side Effects:
** file activity, query printing
**
** Trace Flags:
** 33, 9
*/
void
pr_integrity(char *relid, char *relowner)
{
extern desc_t Intdes;
tid_t hitid, lotid;
struct integrity key, tuple;
register int i;
#ifdef xZTR1
if (tTf(50, 9))
printf("pr_integrity(relid =%s, relowner=%s)\n",
relid, relowner);
#endif
printf("Integrity constraints on %s are:\n\n", relid);
opencatalog("integrities", OR_READ);
/* get integrities tuples for relid, relowner */
clearkeys(&Intdes);
ingres_setkey(&Intdes, &key, relid, INTRELID);
ingres_setkey(&Intdes, &key, relowner, INTRELOWNER);
if ((i = find(&Intdes, EXACTKEY, &lotid, &hitid, &key)) != 0)
syserr("pr_integrity: find %d", i);
for (;;) {
if ((i = get(&Intdes, &lotid, &hitid, &tuple, TRUE)) != 0)
break;
if (kcompare(&Intdes, &tuple, &key) == 0)
pr_int(&tuple, relid);
}
if (i != 1)
syserr("pr_integrity: get %d", i);
}
/*
** XDOT
** add to attribute stash any missing attributes in the
** source relation and then build tree with all attribs
** in the 'a_id' order. This algorithm assumes that
** the function 'attadd' insert attributes into the list
** in 'a_id' order from 1 -> N.
*/
qtree_t *
xdot(int slot)
{
PARRNG *rptr;
attr_t tuple;
register attr_t *ktuple;
attr_t ktup;
tid_t tid;
tid_t limtid;
qtree_t *tempt;
register qtree_t *vnode;
int ik;
register att_ent_t *aptr;
extern PARRNG Parrng[];
extern char *Trname;
extern desc_t Attdes;
rptr = &Parrng[slot];
#ifdef xPTR2
tTfp(35, 0, "ALL being processed for %12s\n",
rptr->vardesc.d_rangevar);
#endif
if (rptr->vardesc.d_r.r_attrc <= 0)
syserr("xdot: rptr->vardesc.d_r.r_attrc %d.\n", rptr->vardesc.d_r.r_attrc);
/* if attstash is missing any attribs then fill in list */
if (rptr->vardesc.d_r.r_attrc != attcount(slot)) {
/* get all entries in attrib relation */
clearkeys(&Attdes);
ktuple = &ktup;
ingres_setkey(&Attdes, ktuple, rptr->vardesc.d_r.r_id, ATTRELID);
ingres_setkey(&Attdes, ktuple, rptr->vardesc.d_r.r_owner, ATTOWNER);
if ((ik = find(&Attdes, EXACTKEY, &tid, &limtid, ktuple)) != 0)
syserr("bad find in xdot '%d'", ik);
while (!get(&Attdes, &tid, &limtid, &tuple, 1))
if (!kcompare(&Attdes, &tuple, ktuple))
/* add any that are not in the stash */
if (!attfind(slot, tuple.a_name))
attadd(slot, &tuple);
}
/* build tree for ALL */
tempt = NULL;
aptr = rptr->attlist;
while (aptr != 0) {
vnode = par_tree(NULL, NULL, VAR, sizeof(varnode_t), slot, aptr);
Trname = aptr->atbname;
tempt = addresdom(tempt, vnode);
aptr = aptr->atbnext;
}
#ifdef xPTR3
tTfp(35, 0, "end of xdot %12s\n", rptr->vardesc.d_rangevar);
#endif
return(tempt);
}
static l_mem atomic (lua_State *L) {
global_State *g = G(L);
l_mem work;
GCObject *origweak, *origall;
GCObject *grayagain = g->grayagain; /* save original list */
lua_assert(g->ephemeron == NULL && g->weak == NULL);
lua_assert(!iswhite(g->mainthread));
g->gcstate = GCSinsideatomic;
g->GCmemtrav = 0; /* start counting work */
markobject(g, L); /* mark running thread */
/* registry and global metatables may be changed by API */
markvalue(g, &g->l_registry);
markmt(g); /* mark global metatables */
/* remark occasional upvalues of (maybe) dead threads */
remarkupvals(g);
propagateall(g); /* propagate changes */
work = g->GCmemtrav; /* stop counting (do not recount 'grayagain') */
g->gray = grayagain;
propagateall(g); /* traverse 'grayagain' list */
g->GCmemtrav = 0; /* restart counting */
convergeephemerons(g);
/* at this point, all strongly accessible objects are marked. */
/* Clear values from weak tables, before checking finalizers */
clearvalues(g, g->weak, NULL);
clearvalues(g, g->allweak, NULL);
origweak = g->weak;
origall = g->allweak;
work += g->GCmemtrav; /* stop counting (objects being finalized) */
separatetobefnz(g, 0); /* separate objects to be finalized */
g->gcfinnum = 1; /* there may be objects to be finalized */
markbeingfnz(g); /* mark objects that will be finalized */
propagateall(g); /* remark, to propagate 'resurrection' */
g->GCmemtrav = 0; /* restart counting */
convergeephemerons(g);
/* at this point, all resurrected objects are marked. */
/* remove dead objects from weak tables */
clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */
clearkeys(g, g->allweak, NULL); /* clear keys from all 'allweak' tables */
/* clear values from resurrected weak tables */
clearvalues(g, g->weak, origweak);
clearvalues(g, g->allweak, origall);
luaS_clearcache(g);
g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
work += g->GCmemtrav; /* complete counting */
return work; /* estimate of memory marked by 'atomic' */
}
static l_mem atomic (lua_State *L) {
global_State *g = G(L);
l_mem work = -cast(l_mem, g->GCmemtrav); /* start counting work */
GCObject *origweak, *origall;
lua_assert(!iswhite(obj2gco(g->mainthread)));
markobject(g, L); /* mark running thread */
/* registry and global metatables may be changed by API */
markvalue(g, &g->l_registry);
markmt(g); /* mark basic metatables */
/* remark occasional upvalues of (maybe) dead threads */
remarkupvals(g);
propagateall(g); /* propagate changes */
work += g->GCmemtrav; /* stop counting (do not (re)count grays) */
/* traverse objects caught by write barrier and by 'remarkupvals' */
retraversegrays(g);
work -= g->GCmemtrav; /* restart counting */
convergeephemerons(g);
/* at this point, all strongly accessible objects are marked. */
/* clear values from weak tables, before checking finalizers */
clearvalues(g, g->weak, NULL);
clearvalues(g, g->allweak, NULL);
origweak = g->weak; origall = g->allweak;
work += g->GCmemtrav; /* stop counting (objects being finalized) */
separatetobefnz(L, 0); /* separate objects to be finalized */
markbeingfnz(g); /* mark objects that will be finalized */
propagateall(g); /* remark, to propagate `preserveness' */
work -= g->GCmemtrav; /* restart counting */
convergeephemerons(g);
/* at this point, all resurrected objects are marked. */
/* remove dead objects from weak tables */
clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */
clearkeys(g, g->allweak, NULL); /* clear keys from all allweak tables */
/* clear values from resurrected weak tables */
clearvalues(g, g->weak, origweak);
clearvalues(g, g->allweak, origall);
g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
work += g->GCmemtrav; /* complete counting */
return work; /* estimate of memory marked by 'atomic' */
}
int os_inputopen(usbdevice* kb){
// The IO service isn't always ready at startup, so if it's not, wait until it is
IOReturn res;
while((res = open_iohid(&kb->event)) != kIOReturnSuccess){
if(res != kIOReturnNotOpen){
// If this is a more serious error, at least print a warning
ckb_err("Unable to open HID system: 0x%08x\n", res);
sleep(1);
continue;
}
usleep(10000);
}
clearkeys(kb);
return 0;
}
