/*
* equality of ktap values. ks == NULL means raw equality
*/
int kp_equalobjv(ktap_State *ks, const Tvalue *t1, const Tvalue *t2)
{
switch (ttype(t1)) {
case KTAP_TNIL:
return 1;
case KTAP_TNUMBER:
return nvalue(t1) == nvalue(t2);
case KTAP_TBOOLEAN:
return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case KTAP_TLIGHTUSERDATA:
return pvalue(t1) == pvalue(t2);
case KTAP_TLCF:
return fvalue(t1) == fvalue(t2);
case KTAP_TSHRSTR:
return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TLNGSTR:
return kp_tstring_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TUSERDATA:
if (uvalue(t1) == uvalue(t2))
return 1;
else if (ks == NULL)
return 0;
case KTAP_TTABLE:
if (hvalue(t1) == hvalue(t2))
return 1;
else if (ks == NULL)
return 0;
default:
return gcvalue(t1) == gcvalue(t2);
}
return 0;
}
/*
* equality of ktap values. ks == NULL means raw equality
*/
int kp_obj_equal(ktap_state *ks, const ktap_value *t1, const ktap_value *t2)
{
switch (ttype(t1)) {
case KTAP_TYPE_NIL:
return 1;
case KTAP_TYPE_NUMBER:
return nvalue(t1) == nvalue(t2);
case KTAP_TYPE_BOOLEAN:
return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case KTAP_TYPE_LIGHTUSERDATA:
return pvalue(t1) == pvalue(t2);
case KTAP_TYPE_CFUNCTION:
return fvalue(t1) == fvalue(t2);
case KTAP_TYPE_SHRSTR:
return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TYPE_LNGSTR:
return kp_str_eqlng(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TYPE_TABLE:
if (hvalue(t1) == hvalue(t2))
return 1;
else if (ks == NULL)
return 0;
case KTAP_TYPE_BTRACE:
return btrace_equal(btvalue(t1), btvalue(t2));
default:
return gcvalue(t1) == gcvalue(t2);
}
return 0;
}
/* Note: 'luaV_equalval()' and 'luaO_rawequalObj()' have largely overlapping
* implementation.
*/
int luaV_equalval (lua_State *L, const TValue *l, const TValue *r) {
const TValue *tm;
lua_assert( ttype_ext(l) == ttype_ext(r) );
switch (ttype(l)) {
case LUA_TNIL: return 1;
#ifdef LUA_TINT
case LUA_TINT:
#endif
case LUA_TNUMBER: return luaO_rawequalObj(l,r);
case LUA_TBOOLEAN: return bvalue(l) == bvalue(r); /* true must be 1 !! */
case LUA_TLIGHTUSERDATA: return pvalue(l) == pvalue(r);
case LUA_TUSERDATA: {
if (uvalue(l) == uvalue(r)) return 1;
tm = get_compTM(L, uvalue(l)->metatable, uvalue(r)->metatable, TM_EQ);
break; /* will try TM */
}
case LUA_TTABLE: {
if (hvalue(l) == hvalue(r)) return 1;
tm = get_compTM(L, hvalue(l)->metatable, hvalue(r)->metatable, TM_EQ);
break; /* will try TM */
}
default: return gcvalue(l) == gcvalue(r);
}
if (tm == NULL) return 0; /* no TM? */
callTMres(L, L->top, tm, l, r); /* call TM */
return !l_isfalse(L->top);
}
int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
const TValue *tm;
lua_assert(ttype(t1) == ttype(t2));
switch (ttype(t1)) {
case LUA_TNIL: return 1;
case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
case LUA_TUSERDATA: {
if (uvalue(t1) == uvalue(t2)) return 1;
tm = get_compTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable,
TM_EQ);
break; /* will try TM */
}
case LUA_TTABLE: {
if (hvalue(t1) == hvalue(t2)) return 1;
tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
default: return gcvalue(t1) == gcvalue(t2);
}
if (tm == NULL) return 0; /* no TM? */
callTMres(L, L->top, tm, t1, t2); /* call TM */
return !l_isfalse(L->top);
}
/*
* equality of ktap values. ks == NULL means raw equality
*/
int kp_equalobjv(ktap_state *ks, const ktap_value *t1, const ktap_value *t2)
{
switch (ttype(t1)) {
case KTAP_TNIL:
return 1;
case KTAP_TNUMBER:
return nvalue(t1) == nvalue(t2);
case KTAP_TBOOLEAN:
return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case KTAP_TLIGHTUSERDATA:
return pvalue(t1) == pvalue(t2);
case KTAP_TLCF:
return fvalue(t1) == fvalue(t2);
case KTAP_TSHRSTR:
return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TLNGSTR:
return kp_tstring_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));
case KTAP_TTABLE:
if (hvalue(t1) == hvalue(t2))
return 1;
else if (ks == NULL)
return 0;
#ifdef __KERNEL__
case KTAP_TBTRACE:
return kp_btrace_equal(btvalue(t1), btvalue(t2));
#endif
default:
return gcvalue(t1) == gcvalue(t2);
}
return 0;
}
/*
** equality of Lua values. L == NULL means raw equality (no metamethods)
*/
int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) {
const TValue *tm;
lua_assert(ttisequal(t1, t2));
switch (ttype(t1)) {
case LUA_TNIL: return 1;
case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
case LUA_TLCF: return fvalue(t1) == fvalue(t2);
case LUA_TSTRING: return eqstr(rawtsvalue(t1), rawtsvalue(t2));
case LUA_TUSERDATA: {
if (uvalue(t1) == uvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
case LUA_TTABLE: {
if (hvalue(t1) == hvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
default:
lua_assert(iscollectable(t1));
return gcvalue(t1) == gcvalue(t2);
}
if (tm == NULL) return 0; /* no TM? */
callTM(L, tm, t1, t2, L->top, 1); /* call TM */
return !l_isfalse(L->top);
}
/*
** Main operation for equality of Lua values; return 't1 == t2'.
** L == NULL means raw equality (no metamethods)
*/
int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
const TValue *tm;
if (ttype(t1) != ttype(t2)) { /* not the same variant? */
#ifndef _KERNEL
if (ttnov(t1) != ttnov(t2) || ttnov(t1) != LUA_TNUMBER)
return 0; /* only numbers can be equal with different variants */
else { /* two numbers with different variants */
lua_Integer i1, i2; /* compare them as integers */
return (tointeger(t1, &i1) && tointeger(t2, &i2) && i1 == i2);
}
#else /* _KERNEL */
return 0; /* numbers have only the integer variant */
#endif /* _KERNEL */
}
/* values have same type and same variant */
switch (ttype(t1)) {
case LUA_TNIL: return 1;
case LUA_TNUMINT: return (ivalue(t1) == ivalue(t2));
#ifndef _KERNEL
case LUA_TNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2));
#endif /* _KERNEL */
case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
case LUA_TLCF: return fvalue(t1) == fvalue(t2);
case LUA_TSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2));
case LUA_TLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2));
case LUA_TUSERDATA: {
if (uvalue(t1) == uvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = fasttm(L, uvalue(t1)->metatable, TM_EQ);
if (tm == NULL)
tm = fasttm(L, uvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
case LUA_TTABLE: {
if (hvalue(t1) == hvalue(t2)) return 1;
else if (L == NULL) return 0;
tm = fasttm(L, hvalue(t1)->metatable, TM_EQ);
if (tm == NULL)
tm = fasttm(L, hvalue(t2)->metatable, TM_EQ);
break; /* will try TM */
}
default:
return gcvalue(t1) == gcvalue(t2);
}
if (tm == NULL) /* no TM? */
return 0; /* objects are different */
luaT_callTM(L, tm, t1, t2, L->top, 1); /* call TM */
return !l_isfalse(L->top);
}
static Node *mainposition (const Table *t, const Tvalue *key)
{
switch (ttype(key)) {
case KTAP_TNUMBER:
return hashnum(t, nvalue(key));
case KTAP_TLNGSTR: {
Tstring *s = rawtsvalue(key);
if (s->tsv.extra == 0) { /* no hash? */
s->tsv.hash = kp_string_hash(getstr(s), s->tsv.len, s->tsv.hash);
s->tsv.extra = 1; /* now it has its hash */
}
return hashstr(t, rawtsvalue(key));
}
case KTAP_TSHRSTR:
return hashstr(t, rawtsvalue(key));
case KTAP_TBOOLEAN:
return hashboolean(t, bvalue(key));
case KTAP_TLIGHTUSERDATA:
return hashpointer(t, pvalue(key));
case KTAP_TLCF:
return hashpointer(t, fvalue(key));
default:
return hashpointer(t, gcvalue(key));
}
}
static PyObject *
Cursor_next(KyotoCursor *self)
{
std::string key;
std::string value;
bool succeed = self->m_cursor->get(&key, &value, true);
if (succeed) {
switch (self->m_type) {
case KYOTO_VALUE: {
return KyotoDB_load(value, self->m_db->use_pickle);
}
case KYOTO_ITEMS:{
APR pkey(KyotoDB_load(key, self->m_db->use_pickle));
APR pvalue(KyotoDB_load(value, self->m_db->use_pickle));
return PyTuple_Pack(2, (PyObject *)pkey, (PyObject *)pvalue);
}
case KYOTO_KEY:
default:
return KyotoDB_load(key, self->m_db->use_pickle);
}
}
PyErr_SetString(PyExc_StopIteration, "");
return NULL;
}
/*
** returns the `main' position of an element in a table (that is, the index
** of its hash value)
**
** Floating point numbers with integer value give the hash position of the
** integer (so they use the same table position).
*/
static Node *mainposition (const Table *t, const TValue *key) {
switch (ttype(key)) {
#ifdef LUA_TINT
case LUA_TINT:
return hashint(t,ivalue(key));
#endif
case LUA_TNUMBER: {
#ifdef LUA_TINT
lua_Integer i;
if (tt_integer_valued(key,&i))
return hashint(t, i);
# ifdef LNUM_COMPLEX
/* Complex numbers are hashed by their scalar part. Pure imaginary values
* with scalar 0 or -0 should give same hash.
*/
if (nvalue_img_fast(key)!=0 && luai_numeq(nvalue_fast(key),0))
return gnode(t, 0); /* 0 and -0 to give same hash */
# endif
#else
if (luai_numeq(nvalue(key),0)) return gnode(t, 0); /* 0 and -0 to give same hash */
#endif
return hashnum(t,nvalue_fast(key));
}
case LUA_TSTRING:
return hashstr(t, rawtsvalue(key));
case LUA_TBOOLEAN:
return hashboolean(t, bvalue(key));
case LUA_TLIGHTUSERDATA:
return hashpointer(t, pvalue(key));
default:
return hashpointer(t, gcvalue(key));
}
}
// -------------------------------------------------------------------
// MyOnlineState
// -------------------------------------------------------------------
void SFSBuddyManager::MyOnlineState(bool value)
{
boost::shared_ptr<bool> pvalue (new bool());
*pvalue = value;
boost::shared_ptr<BuddyVariable> variable(new SFSBuddyVariable(ReservedBuddyVariables::BV_ONLINE, pvalue, VARIABLETYPE_BOOL));
SetMyVariable (variable);
}
void kp_obj_dump(ktap_state_t *ks, const ktap_val_t *v)
{
switch (itype(v)) {
case KTAP_TNIL:
kp_puts(ks, "NIL");
break;
case KTAP_TTRUE:
kp_printf(ks, "true");
break;
case KTAP_TFALSE:
kp_printf(ks, "false");
break;
case KTAP_TNUM:
kp_printf(ks, "NUM %ld", nvalue(v));
break;
case KTAP_TLIGHTUD:
kp_printf(ks, "LIGHTUD 0x%lx", (unsigned long)pvalue(v));
break;
case KTAP_TFUNC:
kp_printf(ks, "FUNCTION 0x%lx", (unsigned long)fvalue(v));
break;
case KTAP_TSTR:
kp_printf(ks, "STR #%s", svalue(v));
break;
case KTAP_TTAB:
kp_printf(ks, "TABLE 0x%lx", (unsigned long)hvalue(v));
break;
default:
kp_printf(ks, "GCVALUE 0x%lx", (unsigned long)gcvalue(v));
break;
}
}
void kp_obj_dump(ktap_state *ks, const ktap_value *v)
{
switch (ttype(v)) {
case KTAP_TYPE_NIL:
kp_puts(ks, "NIL");
break;
case KTAP_TYPE_NUMBER:
kp_printf(ks, "NUMBER %ld", nvalue(v));
break;
case KTAP_TYPE_BOOLEAN:
kp_printf(ks, "BOOLEAN %d", bvalue(v));
break;
case KTAP_TYPE_LIGHTUSERDATA:
kp_printf(ks, "LIGHTUSERDATA 0x%lx", (unsigned long)pvalue(v));
break;
case KTAP_TYPE_CFUNCTION:
kp_printf(ks, "LIGHTCFCUNTION 0x%lx", (unsigned long)fvalue(v));
break;
case KTAP_TYPE_SHRSTR:
case KTAP_TYPE_LNGSTR:
kp_printf(ks, "SHRSTR #%s", svalue(v));
break;
case KTAP_TYPE_TABLE:
kp_printf(ks, "TABLE 0x%lx", (unsigned long)hvalue(v));
break;
default:
kp_printf(ks, "GCVALUE 0x%lx", (unsigned long)gcvalue(v));
break;
}
}
void kp_obj_dump(ktap_State *ks, const Tvalue *v)
{
switch (ttype(v)) {
case KTAP_TNIL:
kp_printf(ks, "NIL");
break;
case KTAP_TNUMBER:
kp_printf(ks, "NUMBER %d", nvalue(v));
break;
case KTAP_TBOOLEAN:
kp_printf(ks, "BOOLEAN %d", bvalue(v));
break;
case KTAP_TLIGHTUSERDATA:
kp_printf(ks, "LIGHTUSERDATA %d", pvalue(v));
break;
case KTAP_TLCF:
kp_printf(ks, "LIGHTCFCUNTION 0x%x", fvalue(v));
break;
case KTAP_TSHRSTR:
case KTAP_TLNGSTR:
kp_printf(ks, "SHRSTR #%s", svalue(v));
break;
case KTAP_TUSERDATA:
kp_printf(ks, "USERDATA %d", uvalue(v));
break;
case KTAP_TTABLE:
kp_printf(ks, "TABLE 0x%x", hvalue(v));
break;
default:
kp_printf(ks, "GCVALUE 0x%x", gcvalue(v));
break;
}
}
int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
if (ttype(t1) != ttype(t2)) return 0;
else switch (ttype(t1)) {
case LUA_TNIL:
return 1;
case LUA_TNUMBER:
return luai_numeq(nvalue(t1), nvalue(t2));
case LUA_TBOOLEAN:
return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */
case LUA_TLIGHTUSERDATA:
return pvalue(t1) == pvalue(t2);
default:
lua_assert(iscollectable(t1));
return gcvalue(t1) == gcvalue(t2);
}
}
int debug_getsize(lua_State* L)
{
TValue* o = L->base;
switch (o->tt) {
/* Container types */
case LUA_TTABLE: {
Table *h = hvalue(o);
lua_pushinteger(L, sizeof(Table) + sizeof(TValue) * h->sizearray +
sizeof(Node) * sizenode(h));
break;
}
case LUA_TFUNCTION: {
Closure *cl = clvalue(o);
lua_pushinteger(L, (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
sizeLclosure(cl->l.nupvalues));
break;
}
case LUA_TTHREAD: {
lua_State *th = thvalue(o);
lua_pushinteger(L, sizeof(lua_State) + sizeof(TValue) * th->stacksize +
sizeof(CallInfo) * th->size_ci);
break;
}
case LUA_TPROTO: {
Proto *p = pvalue(o);
lua_pushinteger(L, sizeof(Proto) + sizeof(Instruction) * p->sizecode +
sizeof(Proto *) * p->sizep +
sizeof(TValue) * p->sizek +
sizeof(int) * p->sizelineinfo +
sizeof(LocVar) * p->sizelocvars +
sizeof(TString *) * p->sizeupvalues);
break;
}
/* Non-containers */
case LUA_TUSERDATA: {
lua_pushnumber(L, uvalue(o)->len);
break;
}
case LUA_TLIGHTUSERDATA: {
lua_pushnumber(L, sizeof(void*));
break;
}
case LUA_TSTRING: {
TString *s = rawtsvalue(o);
lua_pushinteger(L, sizeof(TString) + s->tsv.len + 1);
break;
}
case LUA_TNUMBER: {
lua_pushinteger(L, sizeof(lua_Number));
break;
}
case LUA_TBOOLEAN: {
lua_pushinteger(L, sizeof(int));
break;
}
default: return 0;
}
return 1;
}
static void kp_cdata_value(ktap_state_t *ks, ktap_val_t *val, void **out_addr,
size_t *out_size, void **temp)
{
ktap_cdata_t *cd;
csymbol *cs;
ffi_type type;
switch (ttypenv(val)) {
case KTAP_TYPE_BOOLEAN:
*out_addr = &bvalue(val);
*out_size = sizeof(int);
return;
case KTAP_TYPE_LIGHTUSERDATA:
*out_addr = pvalue(val);
*out_size = sizeof(void *);
return;
case KTAP_TYPE_NUMBER:
*out_addr = &nvalue(val);
*out_size = sizeof(ktap_number);
return;
case KTAP_TYPE_STRING:
*temp = (void *)svalue(val);
*out_addr = temp;
*out_size = sizeof(void *);
return;
}
cd = cdvalue(val);
cs = cd_csym(ks, cd);
type = csym_type(cs);
*out_size = csym_size(ks, cs);
switch (type) {
case FFI_VOID:
kp_error(ks, "Error: Cannot copy data from void type\n");
return;
case FFI_UINT8:
case FFI_INT8:
case FFI_UINT16:
case FFI_INT16:
case FFI_UINT32:
case FFI_INT32:
case FFI_UINT64:
case FFI_INT64:
*out_addr = &cd_int(cd);
return;
case FFI_PTR:
*out_addr = &cd_ptr(cd);
return;
case FFI_STRUCT:
case FFI_UNION:
*out_addr = cd_record(cd);
return;
case FFI_FUNC:
case FFI_UNKNOWN:
kp_error(ks, "Error: internal error for csymbol %s\n",
csym_name(cs));
return;
}
}
LUA_API void *lua_touserdata (lua_State *L, int idx) {
StkId o = index2addr(L, idx);
switch (ttypenv(o)) {
case LUA_TUSERDATA: return (rawuvalue(o) + 1);
case LUA_TLIGHTUSERDATA: return pvalue(o);
default: return NULL;
}
}
LUA_API void *lua_touserdata (lua_State *L, int idx) {
StkId o = luaA_indexAcceptable(L, idx);
if (o == NULL) return NULL;
switch (ttype(o)) {
case LUA_TUSERDATA: return (uvalue(o) + 1);
case LUA_TLIGHTUSERDATA: return pvalue(o);
default: return NULL;
}
}
void kp_obj_show(ktap_state_t *ks, const ktap_val_t *v)
{
switch (itype(v)) {
case KTAP_TNIL:
kp_puts(ks, "nil");
break;
case KTAP_TTRUE:
kp_puts(ks, "true");
break;
case KTAP_TFALSE:
kp_puts(ks, "false");
break;
case KTAP_TNUM:
kp_printf(ks, "%ld", nvalue(v));
break;
case KTAP_TLIGHTUD:
kp_printf(ks, "lightud 0x%lx", (unsigned long)pvalue(v));
break;
case KTAP_TCFUNC:
kp_printf(ks, "cfunction 0x%lx", (unsigned long)fvalue(v));
break;
case KTAP_TFUNC:
kp_printf(ks, "function 0x%lx", (unsigned long)gcvalue(v));
break;
case KTAP_TSTR:
kp_puts(ks, svalue(v));
break;
case KTAP_TTAB:
kp_printf(ks, "table 0x%lx", (unsigned long)hvalue(v));
break;
#ifdef CONFIG_KTAP_FFI
case KTAP_TCDATA:
kp_cdata_dump(ks, cdvalue(v));
break;
#endif
case KTAP_TEVENTSTR:
/* check event context */
if (!ks->current_event) {
kp_error(ks,
"cannot stringify event str in invalid context\n");
return;
}
kp_transport_event_write(ks, ks->current_event);
break;
case KTAP_TKSTACK:
kp_transport_print_kstack(ks, v->val.stack.depth,
v->val.stack.skip);
break;
default:
kp_error(ks, "print unknown value type: %d\n", itype(v));
break;
}
}
int kp_obj_equal(const ktap_val_t *t1, const ktap_val_t *t2)
{
switch (itype(t1)) {
case KTAP_TNIL:
return 1;
case KTAP_TNUM:
return nvalue(t1) == nvalue(t2);
case KTAP_TTRUE:
case KTAP_TFALSE:
return itype(t1) == itype(t2);
case KTAP_TLIGHTUD:
return pvalue(t1) == pvalue(t2);
case KTAP_TFUNC:
return fvalue(t1) == fvalue(t2);
case KTAP_TSTR:
return rawtsvalue(t1) == rawtsvalue(t2);
default:
return gcvalue(t1) == gcvalue(t2);
}
return 0;
}
LUA_API const void *lua_topointer (lua_State *L, int idx) {
StkId o = index2addr(L, idx);
switch (ttype(o)) {
case LUA_TTABLE: return hvalue(o);
case LUA_TLCL: return clLvalue(o);
case LUA_TCCL: return clCvalue(o);
case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o)));
case LUA_TTHREAD: return thvalue(o);
case LUA_TUSERDATA: return getudatamem(uvalue(o));
case LUA_TLIGHTUSERDATA: return pvalue(o);
default: return NULL;
}
}
static PyObject *
KyotoDB_array(KyotoDB *self, int type)
{
PyObject *result = PyList_New(self->m_db->count());
Py_ssize_t i = 0;
kyotocabinet::BasicDB::Cursor *cursor = self->m_db->cursor();
cursor->jump();
std::string key;
std::string value;
while (cursor->get(&key, &value, true)) {
switch (type) {
case 0: {
PyObject *pkey = KyotoDB_load(key, self->use_pickle);
if (pkey == NULL)
goto onerror;
PyList_SetItem(result, i++, pkey);
break;
}
case 1: {
PyObject *pvalue = KyotoDB_load(value, self->use_pickle);
if (pvalue == NULL)
goto onerror;
PyList_SetItem(result, i++, pvalue);
break;
}
case 2: {
APR pkey(KyotoDB_load(key, self->use_pickle));
if (pkey == NULL)
goto onerror;
APR pvalue(KyotoDB_load(value, self->use_pickle));
if (pvalue == NULL)
goto onerror;
PyList_SetItem(result, i++,
PyTuple_Pack(2, (PyObject *)pkey, (PyObject *)pvalue));
break;
}
}
}
delete cursor;
return result;
onerror:
for (Py_ssize_t j = 0; j < i; j++) {
PyObject *obj = PyList_GetItem(result, j);
Py_DECREF(obj);
}
delete cursor;
return NULL;
}
/*
** returns the `main' position of an element in a table (that is, the index
** of its hash value)
*/
static Node *mainposition (const Table *t, const TValue *key) {
switch (ttype(key)) {
case LV_TNUMBER:
return hashnum(t, nvalue(key));
case LV_TSTRING:
return hashstr(t, rawtsvalue(key));
case LV_TBOOLEAN:
return hashboolean(t, bvalue(key));
case LV_TLIGHTUSERDATA:
return hashpointer(t, pvalue(key));
default:
return hashpointer(t, gcvalue(key));
}
}
void kp_obj_show(ktap_state *ks, const ktap_value *v)
{
switch (ttype(v)) {
case KTAP_TYPE_NIL:
kp_puts(ks, "nil");
break;
case KTAP_TYPE_NUMBER:
kp_printf(ks, "%ld", nvalue(v));
break;
case KTAP_TYPE_BOOLEAN:
kp_puts(ks, (bvalue(v) == 1) ? "true" : "false");
break;
case KTAP_TYPE_LIGHTUSERDATA:
kp_printf(ks, "0x%lx", (unsigned long)pvalue(v));
break;
case KTAP_TYPE_CFUNCTION:
kp_printf(ks, "0x%lx", (unsigned long)fvalue(v));
break;
case KTAP_TYPE_SHRSTR:
case KTAP_TYPE_LNGSTR:
kp_puts(ks, svalue(v));
break;
case KTAP_TYPE_TABLE:
kp_tab_dump(ks, hvalue(v));
break;
#ifdef CONFIG_KTAP_FFI
case KTAP_TYPE_CDATA:
kp_cdata_dump(ks, cdvalue(v));
break;
#endif
case KTAP_TYPE_EVENT:
kp_transport_event_write(ks, evalue(v));
break;
case KTAP_TYPE_BTRACE:
btrace_dump(ks, btvalue(v));
break;
case KTAP_TYPE_PTABLE:
kp_ptab_dump(ks, phvalue(v));
break;
case KTAP_TYPE_STATDATA:
kp_statdata_dump(ks, sdvalue(v));
break;
default:
kp_error(ks, "print unknown value type: %d\n", ttype(v));
break;
}
}
void kp_showobj(ktap_state *ks, const ktap_value *v)
{
switch (ttype(v)) {
case KTAP_TNIL:
kp_puts(ks, "nil");
break;
case KTAP_TNUMBER:
kp_printf(ks, "%ld", nvalue(v));
break;
case KTAP_TBOOLEAN:
kp_puts(ks, (bvalue(v) == 1) ? "true" : "false");
break;
case KTAP_TLIGHTUSERDATA:
kp_printf(ks, "0x%lx", (unsigned long)pvalue(v));
break;
case KTAP_TLCF:
kp_printf(ks, "0x%lx", (unsigned long)fvalue(v));
break;
case KTAP_TSHRSTR:
case KTAP_TLNGSTR:
kp_puts(ks, svalue(v));
break;
case KTAP_TUSERDATA:
kp_printf(ks, "0x%lx", (unsigned long)uvalue(v));
break;
case KTAP_TTABLE:
kp_table_dump(ks, hvalue(v));
break;
#ifdef __KERNEL__
case KTAP_TEVENT:
kp_transport_event_write(ks, evalue(v));
break;
case KTAP_TBTRACE:
kp_btrace_dump(ks, btvalue(v));
break;
case KTAP_TAGGRTABLE:
kp_aggrtable_dump(ks, ahvalue(v));
break;
case KTAP_TAGGRACCVAL:
kp_aggraccval_dump(ks, aggraccvalue(v));
break;
#endif
default:
kp_error(ks, "print unknown value type: %d\n", ttype(v));
break;
}
}
/*
** Check whether key 'k1' is equal to the key in node 'n2'.
** This equality is raw, so there are no metamethods. Floats
** with integer values have been normalized, so integers cannot
** be equal to floats. It is assumed that 'eqshrstr' is simply
** pointer equality, so that short strings are handled in the
** default case.
*/
static int equalkey (const TValue *k1, const Node *n2) {
if (rawtt(k1) != keytt(n2)) /* not the same variants? */
return 0; /* cannot be same key */
switch (ttypetag(k1)) {
case LUA_TNIL:
return 1;
case LUA_TNUMINT:
return (ivalue(k1) == keyival(n2));
case LUA_TNUMFLT:
return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2)));
case LUA_TBOOLEAN:
return bvalue(k1) == bvalueraw(keyval(n2));
case LUA_TLIGHTUSERDATA:
return pvalue(k1) == pvalueraw(keyval(n2));
case LUA_TLCF:
return fvalue(k1) == fvalueraw(keyval(n2));
case LUA_TLNGSTR:
return luaS_eqlngstr(tsvalue(k1), keystrval(n2));
default:
return gcvalue(k1) == gcvalueraw(keyval(n2));
}
}
void kp_showobj(ktap_State *ks, const Tvalue *v)
{
switch (ttype(v)) {
case KTAP_TNIL:
kp_printf(ks, "nil");
break;
case KTAP_TNUMBER:
kp_printf(ks, "%d", nvalue(v));
break;
case KTAP_TBOOLEAN:
kp_printf(ks, "%s", (bvalue(v) == 1) ? "true" : "false");
break;
case KTAP_TLIGHTUSERDATA:
kp_printf(ks, "%d", pvalue(v));
break;
case KTAP_TLCF:
kp_printf(ks, "0x%x", fvalue(v));
break;
case KTAP_TSHRSTR:
case KTAP_TLNGSTR:
kp_printf(ks, "\"%s\"", getstr(rawtsvalue(v)));
break;
case KTAP_TUSERDATA:
kp_printf(ks, "%d", uvalue(v));
break;
case KTAP_TTABLE:
kp_table_dump(ks, hvalue(v));
break;
#ifdef __KERNEL__
case KTAP_TEVENT:
kp_show_event(ks);
break;
#endif
default:
kp_printf(ks, "[unknown value type: %d]", ttype(v));
break;
}
}
// -----------------------------------------------------------------------------
// CSIPParamContainerBase::ParseL
// -----------------------------------------------------------------------------
//
void CSIPParamContainerBase::ParseL (const TDesC8& aValue)
{
CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC (aValue,iParamSeparator);
for (TInt i=0; i < tokenizer->Tokens().Count(); i++)
{
TPtrC8 pname;
TPtrC8 pvalue(KNullDesC8);
TBool hasValue = CSIPParam::ParseL(tokenizer->Tokens()[i],pname,pvalue);
CSIPParam* param = CSIPParam::NewLC(pname);
RStringF pnameStr = param->Name();
if (HasParam(pnameStr))
{
User::Leave(KErrSipCodecDuplicateParam);
}
CheckAndUpdateParamL(pnameStr,hasValue,pvalue);
if (hasValue)
{
param->SetValueL(pvalue,AddQuotesWhenEncoding(pnameStr));
}
User::LeaveIfError(iParams.Append(param));
CleanupStack::Pop(param);
}
CleanupStack::PopAndDestroy(tokenizer);
}
void
PermutationTest::
apply()
{
this->M_pValue = 0;
this->M_dataSetPtr1->subtractMeanValue();
this->M_dataSetPtr2->subtractMeanValue();
varCov_Type varCov;
Real dist0(-1);
if ( this->M_mpiUtilityPtr->isMaster() )
{
varCov.setData( this->M_dataSetPtr1->getData() );
matrixPtr_Type varMatrixPtr1( varCov.varCovMatrix() );
varCov.setData( this->M_dataSetPtr2->getData() );
matrixPtr_Type varMatrixPtr2( varCov.varCovMatrix() );
dist0 = this->M_distPtr->compute( varMatrixPtr1, varMatrixPtr2 );
}
MPI_Bcast( & dist0, 1, MPI_DOUBLE_PRECISION, MASTER, MPI_COMM_WORLD );
const UInt N1 = this->M_dataSetPtr1->nbSamples();
const UInt N2 = this->M_dataSetPtr2->nbSamples() ;
std::vector< UInt > drawnSampleIDs;
std::vector< UInt > allSampleIDs( N1 + N2 );
for ( UInt iN(0); iN < N1 + N2; ++iN )
{
allSampleIDs[ iN ] = iN;
}
srand48( this->M_mpiUtilityPtr->myRank() * time( NULL ) );
const UInt niterSlave = static_cast< UInt >( std::ceil( this->M_niter / this->M_mpiUtilityPtr->nbThreads() ) );
const UInt niterMaster = niterSlave + this->M_niter % this->M_mpiUtilityPtr->nbThreads();
printf( "niterSlave = %d \t niterMaster = %d\n", niterSlave, niterMaster );
UInt niterMine;
this->M_mpiUtilityPtr->isMaster() ? niterMine = niterMaster : niterMine = niterSlave;
for ( UInt it(0); it < niterMine; ++it )
{
printf( " Proc %d is at iteration %d of %d\n", this->M_mpiUtilityPtr->myRank(), it, niterMine );
drawnSampleIDs.clear();
drawnSampleIDs.reserve( N1 );
while( drawnSampleIDs.size() != N1 )
{
const UInt temp( static_cast< UInt >( ( N1 + N2 - 1) * drand48() ) );
if ( std::find( drawnSampleIDs.begin(), drawnSampleIDs.end(), temp ) == drawnSampleIDs.end() )
{
drawnSampleIDs.push_back( temp );
}
}
std::sort( drawnSampleIDs.begin(), drawnSampleIDs.end() );
std::vector< UInt > remainingSampleIDs( N2 );
std::set_difference( allSampleIDs.begin(), allSampleIDs.end(),
drawnSampleIDs.begin(), drawnSampleIDs.end(),
remainingSampleIDs.begin() );
dataSetPtr_Type dataUnionPtr( new dataSet_Type( M_dataSetPtr1->getData() ) );
dataUnionPtr->addSamples( this->M_dataSetPtr2->getData() );
/*
std::cout << " SAMPLES " << std::endl;
std::cout << " ** pop 1 " << std::endl;
for ( std::vector< UInt >::iterator it( drawnSampleIDs.begin() ); it != drawnSampleIDs.end(); ++it )
{
std::cout << *it << " ";
}
std::cout << std::endl;
std::cout << " ** pop 2 " << std::endl;
for ( std::vector< UInt >::iterator it( remainingSampleIDs.begin() ); it != remainingSampleIDs.end(); ++it )
{
std::cout << *it << " ";
}
std::cout << std::endl;
dataUnionPtr->showMe();
*/
matrixPtr_Type G1 = dataUnionPtr->getRowSubSet( drawnSampleIDs );
matrixPtr_Type G2 = dataUnionPtr->getRowSubSet( remainingSampleIDs );
// std::cout << " Matrix 1 " << std::endl << *G1 << std::endl << std::endl;
// std::cout << " Matrix 2 " << std::endl << *G2 << std::endl << std::endl;
matrixPtr_Type varG1, varG2;
varCov.setData( G1 ); G1.reset();
varG1 = varCov.varCovMatrix();
varCov.setData( G2 ); G2.reset();
varG2 = varCov.varCovMatrix();
// std::cout << " Var-Cov 1 " << std::endl << *varG1 << std::endl << std::endl;
// std::cout << " Var-Cov 2 " << std::endl << *varG2 << std::endl << std::endl;
const Real distCurr = this->M_distPtr->compute( varG1, varG2 );
printf( "\t DistCurr = %f \t Dist0 = %f\n", distCurr, dist0 );
if( distCurr >= dist0 )
{
this->M_pValue += 1./this->M_niter;
}
}
Real pvalue(-1);
printf( " Proc %d has p-value = %f\n", this->M_mpiUtilityPtr->myRank(), this->M_pValue );
MPI_Reduce( & this->M_pValue, & pvalue, 1, MPI_DOUBLE_PRECISION, MPI_SUM, MASTER, MPI_COMM_WORLD );
MPI_Bcast( & pvalue, 1, MPI_DOUBLE_PRECISION, MASTER, MPI_COMM_WORLD );
this->M_pValue = pvalue;
return;
}
