/* * 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; }