KNHAPI(void) knh_ResultSet_setInt(Ctx *ctx, knh_ResultSet_t *rs, size_t n, knh_int_t value)
{
KNH_ASSERT(n < DP(rs)->column_size);
knh_bytes_t t = {{(const char*)(&value)}, sizeof(knh_int_t)};
DP(rs)->column[n].ctype = knh_ResultSet_CTYPE__integer;
DP(rs)->column[n].start = BA_size(DP(rs)->databuf);
DP(rs)->column[n].len = sizeof(knh_int_t);
knh_Bytes_write(ctx, DP(rs)->databuf, t);
}
static void StartEventHandler(KonohaContext *kctx, void *args)
{
KNH_ASSERT(PLATAPI eventContext == NULL);
struct EventContext *eventContext = (struct EventContext *)PLATAPI malloc_i(sizeof(struct EventContext));
((KonohaFactory *)kctx->platApi)->eventContext = eventContext;
bzero(((KonohaFactory *)kctx->platApi)->eventContext, sizeof(struct EventContext));
eventContext->queue = (LocalQueue *)PLATAPI malloc_i(sizeof(LocalQueue));
LocalQueue_Init(kctx, eventContext->queue);
SetSignal(kctx);
}
KNHAPI(void) knh_ResultSet_setBlob(Ctx *ctx, knh_ResultSet_t *o, size_t n, knh_bytes_t t)
{
KNH_ASSERT(n < DP(o)->column_size);
DP(o)->column[n].ctype = knh_ResultSet_CTYPE__bytes;
DP(o)->column[n].start = BA_size(DP(o)->databuf);
DP(o)->column[n].len = t.len;
knh_Bytes_write(ctx, DP(o)->databuf, t);
int i, c = t.len % sizeof(void*);
for(i = 0; i < c; i++) knh_Bytes_putc(ctx, DP(o)->databuf, 0); /* zero */
}
void knh_path_close(CTX ctx, knh_path_t *ph)
{
knh_Bytes_t *ba = ctx->bufa;
KNH_ASSERT(ph->pstart < ba->bu.len);
//DBG_P("ph='%s', size=%d", P_text(ph), ph->plen);
knh_Bytes_clear(ba, ph->pstart);
ph->pstart = 0;
ph->pbody = 0;
ph->plen = 0;
}
KNHAPI(void) knh_ResultSet_setFloat(Ctx *ctx, knh_ResultSet_t *rs, size_t n, knh_float_t value)
{
KNH_ASSERT(n < DP(rs)->column_size);
knh_bytes_t t = {{(const char*)(&value)}, sizeof(knh_float_t)};
DP(rs)->column[n].ctype = knh_ResultSet_CTYPE__float;
DP(rs)->column[n].start = BA_size(DP(rs)->databuf);
DP(rs)->column[n].len = sizeof(knh_float_t);
knh_Bytes_write(ctx, DP(rs)->databuf, t);
int i, c = t.len % sizeof(void*);
for(i = 0; i < c; i++) knh_Bytes_putc(ctx, DP(rs)->databuf, 0); /* zero */
}
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_int_t knh_Number_tointeger(Any *o)
{
Object *n = (Object*)o;
switch(n->h.bcid) {
case CLASS_Boolean :
return (IS_TRUE(n)) ? 1 : 0;
case CLASS_Int :
return (knh_int_t)((Int*)n)->n.ivalue;
case CLASS_Float :
return (knh_int_t)((Float*)n)->n.fvalue;
}
KNH_ASSERT(n->h.bcid == CLASS_Int); /* STOP */
return 0;
}
static
knh_fmapper knh_fmapper_affine(knh_class_t scid, knh_class_t tcid)
{
if(scid == CLASS_Int) {
if(tcid == CLASS_Int) return knh_AffineConv_fmap__i2i;
KNH_ASSERT(tcid == CLASS_Float);
return knh_AffineConv_fmap__i2f;
}
//KNH_ASSERT(scid == CLASS_Float);
{
if(tcid == CLASS_Int) return knh_AffineConv_fmap__f2i;
//KNH_ASSERT(tcid == CLASS_Float);
return knh_AffineConv_fmap__f2f;
}
}
knh_float_t knh_ResultSet_getFloat(Ctx *ctx, knh_ResultSet_t *o, size_t n)
{
KNH_ASSERT(n < DP(o)->column_size);
const char *p = BA_tochar(DP(o)->databuf) + DP(o)->column[n].start;
switch(DP(o)->column[n].ctype) {
case knh_ResultSet_CTYPE__null :
return K_FLOAT_ZERO;
case knh_ResultSet_CTYPE__integer :
return (knh_float_t)(*((knh_int_t*)p));
case knh_ResultSet_CTYPE__float :
return (knh_float_t)(*((knh_float_t*)p));
case knh_ResultSet_CTYPE__bytes :
TODO();
// return knh_bytes_tofloat(B2(p, DP(o)->column[n].len));
}
return K_FLOAT_ZERO;
}
static METHOD knh__String_concat(Ctx *ctx, knh_sfp_t *sfp)
{
int i, ac = knh_stack_argc(ctx, sfp);
knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf);
knh_sfp_t *esp = KNH_LOCAL(ctx);
for(i = 0; i < ac; i++) {
if(IS_bString(sfp[i].o)) {
knh_Bytes_write(ctx, cwb->ba, knh_String_tobytes(sfp[i].s));
}
else {
KNH_ASSERT(esp == ctx->esp);
KNH_SETv(ctx, esp[1].o, sfp[i].o); esp[1].data = sfp[i].data;
knh_esp1_format(ctx, METHODN__s, cwb->w, KNH_NULL);
}
}
KNH_RETURN(ctx, sfp, knh_cwb_newString(ctx, cwb));
}
static void knh_linkDynamicIconv(CTX ctx)
{
knh_ServiceSPI_t *spi = ((knh_ServiceSPI_t*)ctx->spi);
void *handler = knh_dlopen(ctx, "libiconv" K_OSDLLEXT);
void *f = NULL;
if(handler != NULL) {
f = knh_dlsym(ctx, handler, "iconv_open", "libiconv_open", 1/*isTest*/);
if (f != NULL) {
spi->iconvspi = "libiconv";
spi->iconv_openSPI = (ficonv_open)f;
spi->iconvSPI = (ficonv)knh_dlsym(ctx, handler, "iconv", "libiconv", 0/*isTest*/);
spi->iconv_closeSPI = (ficonv_close)knh_dlsym(ctx, handler, "libiconv_close", "iconv_close", 0);
KNH_ASSERT(spi->iconvSPI != NULL && spi->iconv_closeSPI != NULL);
return ; // OK
}
}
PleaseLetUsKnowYourOS("libiconv is not available");
}
void knh_vperror(Ctx *ctx, knh_uri_t uri, int line, int pe, char *fmt, va_list ap)
{
KNH_ASSERT(pe <= KERR_INFO);
if(knh_Context_isInteractive(ctx)) {
goto L_PRINT;
}
if(pe > KERR_EWARN && !knh_Context_isCompiling(ctx)) {
return;
}
L_PRINT:;
{
OutputStream *w = KNH_STDERR;
knh_printf(ctx, w, " - [%s:%d]:%s ", knh_safefile(URIDN(uri)), (knh_intptr_t)line, KERR_MSG[pe]);
knh_vprintf(ctx, w, fmt, ap);
knh_write_EOL(ctx, w);
((Context*)ctx)->hasError = 1;
}
}
static
ITRNEXT knh_HashMap_var_next(Ctx *ctx, knh_sfp_t *sfp, int n)
{
Iterator *it = sfp[0].it;
knh_Hash_t *o = (knh_Hash_t*)DP(it)->source;
KNH_ASSERT(IS_bHashMap(o));
size_t pos = DP(it)->pos;
size_t max = (KNH_HASH_TABLESIZE / o->hashop->size) * DP(o)->tables_size;
while(pos < max) {
knh_hashentry_t *e = knh_hashentry_at(o, pos);
if(e != NULL) {
DP(it)->pos = pos + 1;
KNH_ITRNEXT(ctx, sfp, n, e->key);
}
pos++;
}
KNH_ITREND(ctx, sfp, n);
}
knh_String_t* knh_ResultSet_getString(Ctx *ctx, knh_ResultSet_t *o, size_t n)
{
KNH_ASSERT(n < DP(o)->column_size);
const char *p = BA_tochar(DP(o)->databuf) + DP(o)->column[n].start;
switch(DP(o)->column[n].ctype) {
case knh_ResultSet_CTYPE__integer :
return new_String__int(ctx, (knh_int_t)(*((knh_int_t*)p)));
case knh_ResultSet_CTYPE__float :
return new_String__float(ctx, (knh_float_t)(*((knh_float_t*)p)));
case knh_ResultSet_CTYPE__text : {
knh_bytes_t t = {{p}, DP(o)->column[n].len};
return new_S(ctx, t);
}
case knh_ResultSet_CTYPE__null :
break;
}
return KNH_TNULL(String);
}
kbytes_t knh_bytes_mofflen(kbytes_t v, size_t moff, size_t mlen)
{
#ifdef K_USING_UTF8
size_t i;
const unsigned char *s = v.utext;
const unsigned char *e = s + v.len;
for(i = 0; i < moff; i++) {
s += utf8len(s[0]);
}
v.ubuf = (kchar_t*)s;
for(i = 0; i < mlen; i++) {
s += utf8len(s[0]);
}
KNH_ASSERT(s <= e);
v.len = (const char*)s - v.text;
return v;
#else
return knh_bytes_subbytes(m, moff, mlen); /* if K_ENCODING is not set */
#endif
}
void *knh_xmalloc(CTX ctx, size_t size)
{
KNH_ASSERT(size >= 0);
knh_xmem_allocator *xalc = &g_xmem_allocator;
if (unlikely(xalc->totalSize == 0)) {
initXmemAllocator(ctx);
}
if (XMEM_IS_PROPSIZE(size)) {
if (XMEM_DOES_FIT(xalc, size)) {
// It fits.
xalc->usedSize += size;
void *ptr = xalc->freelist;
xalc->freelist += size;
return ptr;
}
}
fprintf(stderr,
"Reach the limit allocation for executable memory!!\n"
"You're using:%dbytes, and allocating additional %dbytes\n", xalc->usedSize, size);
return NULL;
}
static METHOD knh__String_opAdd(Ctx *ctx, knh_sfp_t *sfp)
{
knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf);
knh_sfp_t *esp = KNH_LOCAL(ctx);
if(IS_bString(sfp[0].o)) {
knh_Bytes_write(ctx, cwb->ba, knh_String_tobytes(sfp[0].s));
}
else {
KNH_SETv(ctx, esp[1].o, sfp[0].o); esp[1].data = sfp[0].data;
knh_esp1_format(ctx, METHODN__s, cwb->w, KNH_NULL);
}
if(IS_bString(sfp[1].o)) {
knh_Bytes_write(ctx, cwb->ba, knh_String_tobytes(sfp[1].s));
}
else {
KNH_ASSERT(esp == ctx->esp);
KNH_SETv(ctx, esp[1].o, sfp[1].o); esp[1].data = sfp[1].data;
knh_esp1_format(ctx, METHODN__s, cwb->w, KNH_NULL);
}
KNH_RETURN(ctx, sfp, knh_cwb_newString(ctx, cwb));
}
knh_float_t knh_Number_tofloat(Any *o)
{
Object *n = (Object*)o;
switch(n->h.bcid) {
case CLASS_Boolean :
#ifndef KNH_USING_NOFLOAT
return (IS_TRUE(n)) ? 1 : 0;
#else
return (IS_TRUE(n)) ? 1.0 : 0.0;
#endif
case CLASS_Int :
return (knh_float_t)((Int*)n)->n.ivalue;
case CLASS_Float :
return (knh_float_t)((Float*)n)->n.fvalue;
}
KNH_ASSERT(n->h.bcid == CLASS_Int); /* STOP */
#ifndef KNH_USING_NOFLOAT
return (IS_TRUE(n)) ? 1 : 0;
#else
return (IS_TRUE(n)) ? 1.0 : 0.0;
#endif
}
static METHOD knh__String_split(Ctx *ctx, knh_sfp_t *sfp)
{
Array *a = NULL;
int istrim = IS_NULL(sfp[2].o) ? 0 : (int)sfp[2].ivalue;
if(IS_NULL(sfp[1].o)) {
a = knh_String_toCharArray(ctx, sfp[0].s, istrim);
}
else {
knh_bytes_t delim = knh_String_tobytes(sfp[1].s);
if(delim.len == 0) {
a = knh_String_toCharArray(ctx, sfp[0].s, istrim);
}
else {
knh_bytes_t base = knh_String_tobytes(sfp[0].s);
a = new_Array(ctx, CLASS_String, 8);
while(1) {
knh_index_t loc = knh_bytes_indexOf(base, delim);
if(loc == -1) {
if(istrim) base = knh_bytes_trim(base);
knh_Array_add(ctx, a, UP(new_String(ctx, base, sfp[0].s)));
break;
}
else if(loc == 0) {
knh_Array_add(ctx, a, UP(TS_EMPTY));
}
else {
knh_bytes_t t = knh_bytes_first(base, loc);
if(istrim) t = knh_bytes_trim(t);
knh_Array_add(ctx, a, UP(new_String(ctx, t, sfp[0].s)));
}
base.buf = base.buf + loc + delim.len;
base.len = base.len - loc - delim.len;
}
}
}
KNH_ASSERT(a != NULL);
KNH_RETURN(ctx, sfp, a);
}
void knh_Stmt__s(Ctx *ctx, Stmt *o, OutputStream *w, String *m)
{
knh_intptr_t i;
knh_putc(ctx, w, '(');
if(SP(o)->stt != STT_OP && SP(o)->stt != STT_NEW && SP(o)->stt != STT_CALL ) {
knh_write_char(ctx, w, knh_stmt_tochar(SP(o)->stt));
if(DP(o)->size > 0) {
knh_putc(ctx, w, ' ');
}
}
for(i = 0; i < DP(o)->size; i++) {
if(i > 0) knh_putc(ctx, w, ' ');
if(IS_Token(DP(o)->terms[i])) {
knh_Token__s(ctx, DP(o)->tokens[i], w, m);
} else {
KNH_ASSERT(IS_Stmt(DP(o)->terms[i]));
knh_Stmt__s(ctx, DP(o)->stmts[i], w, m);
if(IS_NOTNULL(DP(DP(o)->stmts[i])->next)) {
knh_write_dots(ctx, w);
}
}
}
knh_putc(ctx, w, ')');
}
knh_String_t *knh_ResultSet_getName(Ctx *ctx, knh_ResultSet_t *o, size_t n)
{
KNH_ASSERT(n < DP(o)->column_size);
return DP(o)->column[n].name;
}
knh_type_t knh_ResultSet_get_type(Ctx *ctx, knh_ResultSet_t *o, size_t n)
{
KNH_ASSERT(n < DP(o)->column_size);
return DP(o)->column[n].type;
}
KNHAPI(void) knh_ResultSet_setName(Ctx *ctx, knh_ResultSet_t *o, size_t n, knh_String_t *name)
{
KNH_ASSERT(n < DP(o)->column_size);
KNH_SETv(ctx, DP(o)->column[n].name, name);
}
static METHOD Object_getKey(Ctx *ctx, knh_sfp_t *sfp, long rix)
{
knh_String_t *s = ClassTBL(knh_Object_bcid(sfp[0].o)).cspi->getkey(ctx, sfp);
KNH_ASSERT(IS_String(s));
RETURN_(s);
}
