static knh_Actor_t *knh_Actor_new(CTX ctx, knh_bytes_t name, knh_bytes_t host, int port)
{
knh_Actor_t *actor = (knh_Actor_t *)new_O(Actor, knh_getcid(ctx, STEXT("Actor")));
KNH_INITv(actor->name, new_String2(ctx, CLASS_String, name.text, name.len, 0));
KNH_INITv(actor->host, new_String2(ctx, CLASS_String, host.text, host.len, 0));
actor->port = port;
return actor;
}
/* ======================================================================== */
static knh_device_t* new_device(Ctx *ctx, knh_String_t *str)
{
knh_device_t *d = kmalloc(sizeof(knh_device_t), GFP_KERNEL);
printk("%s:%d,%d\n",__func__,__LINE__,sizeof(knh_device_t));
KNH_INITv(d->name, str);
KNH_INITv(d->read, KNH_NULL);
KNH_INITv(d->write, KNH_NULL);
printk("%s\n",__func__);
return d;
}
static void knh_Exception_addStackTrace(CTX ctx, kException *e, ksfp_t *sfp)
{
CWB_t cwbbuf, *cwb = CWB_open0(ctx, &cwbbuf);
kMethod *mtd = sfp[K_MTDIDX].mtdNC;
if((mtd)->mn != MN_LAMBDA) {
int i = 0, psize = knh_Method_psize(mtd);
kline_t uline = knh_stack_uline(ctx, sfp);
knh_write_uline(ctx, cwb->w, uline);
knh_write_type(ctx, cwb->w, (mtd)->cid);
knh_putc(ctx, cwb->w, '.');
knh_write_mn(ctx, cwb->w, (mtd)->mn);
knh_putc(ctx, cwb->w, '(');
for(i = 0; i < psize; i++) {
kparam_t *p = knh_Param_get(DP(mtd)->mp, i);
ktype_t type = ktype_tocid(ctx, p->type, O_cid(sfp[0].o));
if(i > 0) {
knh_putc(ctx, cwb->w, ',');
}
knh_write_fn(ctx, cwb->w, p->fn);
knh_putc(ctx, cwb->w, '=');
knh_write_sfp(ctx, cwb->w, type, &sfp[i+1], FMT_line);
}
knh_putc(ctx, cwb->w, ')');
if(e->tracesNULL == NULL) {
KNH_INITv(e->tracesNULL, new_Array(ctx, CLASS_String, 0));
}
knh_Array_add(ctx, e->tracesNULL, CWB_newString0(ctx, cwb));
}
}
KNHAPI(void) knh_ResultSet_initColumn(Ctx *ctx, knh_ResultSet_t *o, size_t column_size)
{
size_t i;
if(DP(o)->column_size != 0) {
for(i = 0; i < DP(o)->column_size; i++) {
KNH_FINALv(ctx, DP(o)->column[i].name);
}
KNH_FREE(ctx, DP(o)->column, sizeof(knh_dbschema_t) * DP(o)->column_size);
DP(o)->column = NULL;
if(DP(o)->qcur != NULL) {
DP(o)->qcurfree(DP(o)->qcur);
DP(o)->qcur = NULL;
}
}
DP(o)->column_size = column_size;
if(column_size > 0) {
DP(o)->column = (knh_dbschema_t*)KNH_MALLOC(ctx, sizeof(knh_dbschema_t) * DP(o)->column_size);
for(i = 0; i < DP(o)->column_size; i++) {
DP(o)->column[i].type = CLASS_Object;
KNH_INITv(DP(o)->column[i].name, TS_EMPTY);
DP(o)->column[i].start = 0;
DP(o)->column[i].len = 0;
}
}
DP(o)->count = 0;
}
void knh_OutputStream_setCharset(Ctx *ctx, knh_OutputStream_t *w, knh_StringEncoder_t *c)
{
if(DP(w)->encNULL == NULL) {
KNH_INITv(DP(w)->encNULL, c);
}
else {
KNH_SETv(ctx, DP(w)->encNULL, c);
}
}
KNHAPI2(void) knh_Array_add_(CTX ctx, kArray *a, kObject *value)
{
size_t capacity = a->dim->capacity;
if(a->size == capacity) {
knh_Array_grow(ctx, a, k_grow(capacity), a->size + 1);
}
KNH_INITv(a->list[a->size], value);
a->size++;
}
static void CommonContext_init(CTX ctx, kcontext_t *o)
{
KNH_ASSERT_CTX0(ctx);
DBG_ASSERT(o->script != NULL);
DBG_ASSERT(o->gma != NULL);
KNH_INITv(o->enc, ctx->share->enc);
KNH_INITv(o->in, ctx->share->in);
KNH_INITv(o->out, ctx->share->out);
KNH_INITv(o->err, ctx->share->err);
KNH_INITv(o->e, KNH_NULL);
KNH_INITv(o->evaled, KNH_NULL);
KNH_INITv(o->errmsgs, new_Array0(ctx, 0));
KNH_INITv(o->gcstack, new_Array0(ctx, 0));
#ifndef K_USING_STRINGPOOL
KNH_INITv(o->symbolDictMap, new_DictMap0(ctx, 256, 0/*isCaseMap*/, "Context.symbolDictMap"));
#endif
// KNH_INITv(o->constPools, new_Array0(ctx, 0));
o->ctxlock = knh_mutex_malloc(ctx);
}
static METHOD knh__HashMap_set(Ctx *ctx, knh_sfp_t *sfp)
{
if(IS_IMM(sfp[0].o)) {
if(IS_NULL(sfp[2].o)) {
knh__HashMap_remove(ctx, sfp);
return ;
}
knh_Hash_t *o = (knh_Hash_t*)sfp[0].o;
knh_hcode_t hcode = knh_stack_hashCode(ctx, sfp + 1);
knh_uintptr_t h = hcode % DP(o)->hmax;
knh_hashentry_t *e = DP(o)->array[h];
while(e != NULL) {
if(e->hcode == hcode
&& knh_Object_cid(sfp[1].o) == knh_Object_cid(e->key)
&& knh_stack_equals(ctx, sfp + 1, e->key)) {
knh_sfp_boxing(ctx, sfp+2);
KNH_SETv(ctx, e->value, sfp[2].o);
KNH_RETURN_void(ctx, sfp);
}
e = e->next;
}
/* add newentry */ {
e = new_hashentry(ctx, o);
e->hcode = hcode;
knh_sfp_boxing(ctx, sfp+1);
KNH_INITv(e->key, sfp[1].o);
knh_sfp_boxing(ctx, sfp+2);
KNH_INITv(e->value, sfp[2].o);
e->next = DP(o)->array[h];
DP(o)->array[h] = e;
DP(o)->size++;
}
}
KNH_RETURN_void(ctx, sfp);
}
static
void knh_Stmt_terms_expand(Ctx *ctx, Stmt *o)
{
size_t i, newcapacity = DP(o)->capacity * 2;
Object **newterms = (Object**)KNH_MALLOC(ctx, sizeof(Object*) * newcapacity);
knh_memcpy(newterms, DP(o)->terms, sizeof(Object*) * DP(o)->capacity);
for(i = DP(o)->capacity; i < newcapacity; i++) {
KNH_INITv(newterms[i], KNH_NULL);
}
KNH_FREE(ctx, DP(o)->terms, sizeof(Object*) * DP(o)->capacity);
DP(o)->terms = newterms;
DP(o)->capacity = newcapacity;
KNH_ASSERT(DP(o)->size < DP(o)->capacity);
}
knh_fieldn_t knh_addname(Ctx *ctx, knh_String_t *s, knh_Fdictset f)
{
knh_SystemEX_t *b = DP(ctx->sys);
size_t n = knh_DictSet_size(b->nameDictCaseSet);
if(n == b->hnameinfo[-1].capacity) {
b->hnameinfo = knh_hrealloc(ctx, b->hnameinfo, n * 2);
}
DBG_ASSERT(n < b->hnameinfo[-1].capacity);
KNH_INITv(b->nameinfo[n].name, s);
if(unlikely(!(n+1 < K_FLAG_MN_SETTER))) { /* Integer overflowed */
KNH_SYSLOG(ctx, LOG_CRIT, "TooManyNames", "last nameid(fn)=%d < %d", (int)(n+1), (int)K_FLAG_MN_SETTER);
}
f(ctx, b->nameDictCaseSet, s, n + 1);
return (knh_fieldn_t)(n);
}
void knh_InputStream_setCharset(Ctx *ctx, knh_InputStream_t *in, knh_StringDecoder_t *c)
{
if(DP(in)->decNULL == NULL) {
if(c != NULL) {
KNH_INITv(DP(in)->decNULL, c);
}
}
else {
if(c != NULL) {
KNH_SETv(ctx, DP(in)->decNULL, c);
}
else {
KNH_FINALv(ctx, DP(in)->decNULL);
DP(in)->decNULL = c;
}
}
}
static knh_sfp_t *knh_Exception_addStackTrace(Ctx *ctx, knh_Exception_t *e, knh_sfp_t *sfp)
{
knh_intptr_t shift = sfp[K_SHIFTIDX].shift;
knh_sfp_t *psfp = sfp - shift;
if(ctx->stack < psfp && psfp < sfp) {
if(psfp[K_MTDIDX].callmtd != NULL && isCalledMethod(ctx, psfp + K_MTDIDX)) {
knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf);
knh_opline_t *pc = psfp[K_SHIFTIDX].pc;
knh_Method_t *mtd = psfp[K_MTDIDX].callmtd;
int linenum = pc->line;
const char *file = knh_Method_file(ctx, mtd);
knh_write_cline(ctx, cwb->w, file, linenum);
knh_putc(ctx, cwb->w, ':');
knh_stack_writeStackTrace(ctx, sfp, cwb->w);
if(DP(e)->tracesNULL == NULL) {
KNH_INITv(DP(e)->tracesNULL, new_Array(ctx, CLASS_String, 0));
}
knh_Array_add(ctx, DP(e)->tracesNULL, knh_cwb_newString(ctx, cwb));
sfp = psfp;
}
}
return sfp - 1;
}
int knh_addClassConst(Ctx *ctx, knh_class_t cid, knh_String_t* name, Object *value)
{
int ret;
knh_DictCaseMap_t *cmap = ClassTBL(cid).constDictCaseMapNULL;
DBG_ASSERT_cid(cid);
if(cmap == NULL) {
knh_ClassTBL_t *t = pClassTBL(ctx, cid);
cmap = new_DictCaseMap0(ctx, 0);
KNH_INITv(t->constDictCaseMapNULL, cmap);
}
DBG_ASSERT(IS_Map(cmap));
OLD_LOCK(ctx, LOCK_SYSTBL, NULL);
int idx = knh_DictCaseMap_index(cmap, S_tobytes(name));
if(idx != -1) {
ret = 0;
goto L_UNLOCK;
}
knh_DictCaseMap_set(ctx, cmap, name, value);
ret = 1;
L_UNLOCK:
OLD_UNLOCK(ctx, LOCK_SYSTBL, NULL);
return ret;
}
