object
hashMapFindNode(Thread* t, object map, object key,
uint32_t (*hash)(Thread*, object),
bool (*equal)(Thread*, object, object))
{
bool weak = objectClass(t, map) == type(t, Machine::WeakHashMapType);
object array = hashMapArray(t, map);
if (array) {
unsigned index = hash(t, key) & (arrayLength(t, array) - 1);
for (object n = arrayBody(t, array, index); n; n = tripleThird(t, n)) {
object k = tripleFirst(t, n);
if (weak) {
k = jreferenceTarget(t, k);
if (k == 0) {
continue;
}
}
if (equal(t, key, k)) {
return n;
}
}
}
return 0;
}
void
hashMapInsert(Thread* t, object map, object key, object value,
uint32_t (*hash)(Thread*, object))
{
// note that we reinitialize the array variable whenever an
// allocation (and thus possibly a collection) occurs, in case the
// array changes due to a table resize.
PROTECT(t, map);
uint32_t h = hash(t, key);
bool weak = objectClass(t, map) == type(t, Machine::WeakHashMapType);
object array = hashMapArray(t, map);
++ hashMapSize(t, map);
if (array == 0 or hashMapSize(t, map) >= arrayLength(t, array) * 2) {
PROTECT(t, key);
PROTECT(t, value);
hashMapResize(t, map, hash, array ? arrayLength(t, array) * 2 : 16);
array = hashMapArray(t, map);
}
object k = key;
if (weak) {
PROTECT(t, key);
PROTECT(t, value);
object r = makeWeakReference(t, 0, 0, 0, 0);
jreferenceTarget(t, r) = key;
jreferenceVmNext(t, r) = t->m->weakReferences;
t->m->weakReferences = r;
k = r;
array = hashMapArray(t, map);
}
object n = makeTriple(t, k, value, 0);
array = hashMapArray(t, map);
unsigned index = h & (arrayLength(t, array) - 1);
set(t, n, TripleThird, arrayBody(t, array, index));
set(t, array, ArrayBody + (index * BytesPerWord), n);
if (hashMapSize(t, map) <= arrayLength(t, array) / 3) {
// this might happen if nodes were removed during GC in which case
// we weren't able to resize at the time
hashMapResize(t, map, hash, arrayLength(t, array) / 2);
}
}
void
hashMapResize(Thread* t, object map, uint32_t (*hash)(Thread*, object),
unsigned size)
{
PROTECT(t, map);
object newArray = 0;
if (size) {
object oldArray = hashMapArray(t, map);
PROTECT(t, oldArray);
unsigned newLength = nextPowerOfTwo(size);
if (oldArray and arrayLength(t, oldArray) == newLength) {
return;
}
newArray = makeArray(t, newLength);
if (oldArray != hashMapArray(t, map)) {
// a resize was performed during a GC via the makeArray call
// above; nothing left to do
return;
}
if (oldArray) {
bool weak = objectClass(t, map) == type(t, Machine::WeakHashMapType);
for (unsigned i = 0; i < arrayLength(t, oldArray); ++i) {
object next;
for (object p = arrayBody(t, oldArray, i); p; p = next) {
next = tripleThird(t, p);
object k = tripleFirst(t, p);
if (weak) {
k = jreferenceTarget(t, k);
if (k == 0) {
continue;
}
}
unsigned index = hash(t, k) & (newLength - 1);
set(t, p, TripleThird, arrayBody(t, newArray, index));
set(t, newArray, ArrayBody + (index * BytesPerWord), p);
}
}
}
}
set(t, map, HashMapArray, newArray);
}
object
hashMapRemove(Thread* t, object map, object key,
uint32_t (*hash)(Thread*, object),
bool (*equal)(Thread*, object, object))
{
bool weak = objectClass(t, map) == type(t, Machine::WeakHashMapType);
object array = hashMapArray(t, map);
object o = 0;
if (array) {
unsigned index = hash(t, key) & (arrayLength(t, array) - 1);
object p = 0;
for (object n = arrayBody(t, array, index); n;) {
object k = tripleFirst(t, n);
if (weak) {
k = jreferenceTarget(t, k);
if (k == 0) {
n = tripleThird(t, hashMapRemoveNode(t, map, index, p, n));
continue;
}
}
if (equal(t, key, k)) {
o = tripleSecond(t, hashMapRemoveNode(t, map, index, p, n));
break;
} else {
p = n;
n = tripleThird(t, n);
}
}
if ((not t->m->collecting)
and hashMapSize(t, map) <= arrayLength(t, array) / 3)
{
PROTECT(t, o);
hashMapResize(t, map, hash, arrayLength(t, array) / 2);
}
}
return o;
}
/*
* Function: checkSELinuxAccess
* Purpose: Check permissions between two security contexts.
* Parameters: subjectContextStr: subject security context as a string
* objectContextStr: object security context as a string
* objectClassStr: object's security class name as a string
* permissionStr: permission name as a string
* Returns: boolean: (true) if permission was granted, (false) otherwise
* Exceptions: None
*/
static jboolean checkSELinuxAccess(JNIEnv *env, jobject, jstring subjectContextStr,
jstring objectContextStr, jstring objectClassStr, jstring permissionStr) {
if (isSELinuxDisabled) {
return true;
}
ScopedUtfChars subjectContext(env, subjectContextStr);
if (subjectContext.c_str() == NULL) {
return false;
}
ScopedUtfChars objectContext(env, objectContextStr);
if (objectContext.c_str() == NULL) {
return false;
}
ScopedUtfChars objectClass(env, objectClassStr);
if (objectClass.c_str() == NULL) {
return false;
}
ScopedUtfChars permission(env, permissionStr);
if (permission.c_str() == NULL) {
return false;
}
char *tmp1 = const_cast<char *>(subjectContext.c_str());
char *tmp2 = const_cast<char *>(objectContext.c_str());
int accessGranted = selinux_check_access(tmp1, tmp2, objectClass.c_str(), permission.c_str(),
NULL);
ALOGV("checkSELinuxAccess(%s, %s, %s, %s) => %d", subjectContext.c_str(), objectContext.c_str(),
objectClass.c_str(), permission.c_str(), accessGranted);
return (accessGranted == 0) ? true : false;
}
WRITE16_MEMBER(aerofgt_state::aerofgt_bg1scrollx_w)
{
COMBINE_DATA(&m_bg1scrollx);
}
WRITE16_MEMBER(aerofgt_state::aerofgt_bg1scrolly_w)
{
COMBINE_DATA(&m_bg1scrolly);
}
WRITE16_MEMBER(aerofgt_state::aerofgt_bg2scrollx_w)
{
COMBINE_DATA(&m_bg2scrollx);
}
WRITE16_MEMBER(aerofgt_state::aerofgt_bg2scrolly_w)
{
COMBINE_DATA(&m_bg2scrolly);
}
WRITE16_MEMBER(aerofgt_state::pspikes_palette_bank_w)
{
if (ACCESSING_BITS_0_7)
{
m_spritepalettebank = data & 0x03;
if (m_charpalettebank != (data & 0x1c) >> 2)
{
m_charpalettebank = (data & 0x1c) >> 2;
m_bg1_tilemap->mark_all_dirty();
}
}
}
/***************************************************************************
Display refresh
***************************************************************************/
UINT32 aerofgt_state::screen_update_pspikes(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
{
int i, scrolly;
/** get value of a field of an object or class
object (int), return signature (string), field name (string)
arrays and objects are returned as IDs (hence not evaluated)
class name can be in either form / or .
*/
REPC SEXP RgetField(SEXP obj, SEXP sig, SEXP name, SEXP trueclass) {
jobject o = 0;
SEXP e;
const char *retsig, *fnam;
char *clnam = 0, *detsig = 0;
jfieldID fid;
jclass cls;
int tc = asInteger(trueclass);
JNIEnv *env=getJNIEnv();
if (obj == R_NilValue) return R_NilValue;
if ( IS_JOBJREF(obj) )
obj = GET_SLOT(obj, install("jobj"));
if (TYPEOF(obj)==EXTPTRSXP) {
jverify(obj);
o=(jobject)EXTPTR_PTR(obj);
} else if (TYPEOF(obj)==STRSXP && LENGTH(obj)==1)
clnam = strdup(CHAR(STRING_ELT(obj, 0)));
else
error("invalid object parameter");
if (!o && !clnam)
error("cannot access a field of a NULL object");
#ifdef RJ_DEBUG
if (o) {
rjprintf("RgetField.object: "); printObject(env, o);
} else {
rjprintf("RgetField.class: %s\n", clnam);
}
#endif
if (o)
cls = objectClass(env, o);
else {
char *c = clnam;
while(*c) { if (*c=='/') *c='.'; c++; }
cls = findClass(env, clnam);
free(clnam);
if (!cls) {
error("cannot find class %s", CHAR(STRING_ELT(obj, 0)));
}
}
if (!cls)
error("cannot determine object class");
#ifdef RJ_DEBUG
rjprintf("RgetField.class: "); printObject(env, cls);
#endif
if (TYPEOF(name)!=STRSXP || LENGTH(name)!=1) {
releaseObject(env, cls);
error("invalid field name");
}
fnam = CHAR(STRING_ELT(name,0));
if (sig == R_NilValue) {
retsig = detsig = findFieldSignature(env, cls, fnam);
if (!retsig) {
releaseObject(env, cls);
error("unable to detect signature for field '%s'", fnam);
}
} else {
if (TYPEOF(sig)!=STRSXP || LENGTH(sig)!=1) {
releaseObject(env, cls);
error("invalid signature parameter");
}
retsig = CHAR(STRING_ELT(sig,0));
}
_dbg(rjprintf("field %s signature is %s\n",fnam,retsig));
if (o) { /* first try non-static fields */
fid = (*env)->GetFieldID(env, cls, fnam, retsig);
checkExceptionsX(env, 1);
if (!fid) { /* if that fails, try static ones */
o = 0;
fid = (*env)->GetStaticFieldID(env, cls, fnam, retsig);
}
} else /* no choice if the object was a string */
fid = (*env)->GetStaticFieldID(env, cls, fnam, retsig);
if (!fid) {
checkExceptionsX(env, 1);
releaseObject(env, cls);
if (detsig) free(detsig);
error("RgetField: field %s not found", fnam);
}
switch (*retsig) {
case 'I': {
int r=o?
(*env)->GetIntField(env, o, fid):
(*env)->GetStaticIntField(env, cls, fid);
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'S': {
jshort r=o?
(*env)->GetShortField(env, o, fid):
(*env)->GetStaticShortField(env, cls, fid);
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'C': {
int r=(int) (o?
(*env)->GetCharField(env, o, fid):
(*env)->GetStaticCharField(env, cls, fid));
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'B': {
int r=(int) (o?
(*env)->GetByteField(env, o, fid):
(*env)->GetStaticByteField(env, cls, fid));
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'J': {
jlong r=o?
(*env)->GetLongField(env, o, fid):
(*env)->GetStaticLongField(env, cls, fid);
e = allocVector(REALSXP, 1);
REAL(e)[0] = (double)r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'Z': {
jboolean r=o?
(*env)->GetBooleanField(env, o, fid):
(*env)->GetStaticBooleanField(env, cls, fid);
e = allocVector(LGLSXP, 1);
LOGICAL(e)[0] = r?1:0;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'D': {
double r=o?
(*env)->GetDoubleField(env, o, fid):
(*env)->GetStaticDoubleField(env, cls, fid);
e = allocVector(REALSXP, 1);
REAL(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'F': {
double r = (double) (o?
(*env)->GetFloatField(env, o, fid):
(*env)->GetStaticFloatField(env, cls, fid));
e = allocVector(REALSXP, 1);
REAL(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'L':
case '[': {
SEXP rv;
jobject r = o?
(*env)->GetObjectField(env, o, fid):
(*env)->GetStaticObjectField(env, cls, fid);
_mp(MEM_PROF_OUT(" %08x LNEW field value\n", (int) r))
releaseObject(env, cls);
if (tc) {
if (detsig) free(detsig);
return new_jobjRef(env, r, 0);
}
if (*retsig=='L') { /* need to fix the class name */
char *d = strdup(retsig), *c = d;
while (*c) { if (*c==';') { *c=0; break; }; c++; }
rv = new_jobjRef(env, r, d+1);
free(d);
} else
rv = new_jobjRef(env, r, retsig);
if (detsig) free(detsig);
return rv;
}
} /* switch */
releaseObject(env, cls);
if (detsig) {
free(detsig);
error("unknown field signature");
}
error("unknown field signature '%s'", retsig);
return R_NilValue;
}
REPC SEXP RsetField(SEXP ref, SEXP name, SEXP value) {
jobject o = 0, otr;
SEXP obj = ref;
const char *fnam;
sig_buffer_t sig;
char *clnam = 0;
jfieldID fid;
jclass cls;
jvalue jval;
JNIEnv *env=getJNIEnv();
if (TYPEOF(name)!=STRSXP && LENGTH(name)!=1)
error("invalid field name");
fnam = CHAR(STRING_ELT(name, 0));
if (obj == R_NilValue) error("cannot set a field of a NULL object");
if (IS_JOBJREF(obj))
obj = GET_SLOT(obj, install("jobj"));
if (TYPEOF(obj)==EXTPTRSXP) {
jverify(obj);
o=(jobject)EXTPTR_PTR(obj);
} else if (TYPEOF(obj)==STRSXP && LENGTH(obj)==1)
clnam = strdup(CHAR(STRING_ELT(obj, 0)));
else
error("invalid object parameter");
if (!o && !clnam)
error("cannot set a field of a NULL object");
#ifdef RJ_DEBUG
if (o) {
rjprintf("RsetField.object: "); printObject(env, o);
} else {
rjprintf("RsetField.class: %s\n", clnam);
}
#endif
if (o)
cls = objectClass(env, o);
else {
char *c = clnam;
while(*c) { if (*c=='/') *c='.'; c++; }
cls = findClass(env, clnam);
if (!cls) {
error("cannot find class %s", CHAR(STRING_ELT(obj, 0)));
}
}
if (!cls)
error("cannot determine object class");
#ifdef RJ_DEBUG
rjprintf("RsetField.class: "); printObject(env, cls);
#endif
init_sigbuf(&sig);
jval = R1par2jvalue(env, value, &sig, &otr);
if (o) {
fid = (*env)->GetFieldID(env, cls, fnam, sig.sig);
if (!fid) {
checkExceptionsX(env, 1);
o = 0;
fid = (*env)->GetStaticFieldID(env, cls, fnam, sig.sig);
}
} else
fid = (*env)->GetStaticFieldID(env, cls, fnam, sig.sig);
if (!fid) {
checkExceptionsX(env, 1);
releaseObject(env, cls);
if (otr) releaseObject(env, otr);
done_sigbuf(&sig);
error("cannot find field %s with signature %s", fnam, sig.sigbuf);
}
switch(sig.sig[0]) {
case 'Z':
o?(*env)->SetBooleanField(env, o, fid, jval.z):
(*env)->SetStaticBooleanField(env, cls, fid, jval.z);
break;
case 'C':
o?(*env)->SetCharField(env, o, fid, jval.c):
(*env)->SetStaticCharField(env, cls, fid, jval.c);
break;
case 'B':
o?(*env)->SetByteField(env, o, fid, jval.b):
(*env)->SetStaticByteField(env, cls, fid, jval.b);
break;
case 'I':
o?(*env)->SetIntField(env, o, fid, jval.i):
(*env)->SetStaticIntField(env, cls, fid, jval.i);
break;
case 'D':
o?(*env)->SetDoubleField(env, o, fid, jval.d):
(*env)->SetStaticDoubleField(env, cls, fid, jval.d);
break;
case 'F':
o?(*env)->SetFloatField(env, o, fid, jval.f):
(*env)->SetStaticFloatField(env, cls, fid, jval.f);
break;
case 'J':
o?(*env)->SetLongField(env, o, fid, jval.j):
(*env)->SetStaticLongField(env, cls, fid, jval.j);
break;
case 'S':
o?(*env)->SetShortField(env, o, fid, jval.s):
(*env)->SetStaticShortField(env, cls, fid, jval.s);
break;
case '[':
case 'L':
o?(*env)->SetObjectField(env, o, fid, jval.l):
(*env)->SetStaticObjectField(env, cls, fid, jval.l);
break;
default:
releaseObject(env, cls);
if (otr) releaseObject(env, otr);
done_sigbuf(&sig);
error("unknown field sighanture %s", sig.sigbuf);
}
done_sigbuf(&sig);
releaseObject(env, cls);
if (otr) releaseObject(env, otr);
return ref;
}
