// ## Array[AprTableEntry] AprTable.getElts() static KMETHOD AprTable_getElts(KonohaContext *kctx, KonohaStack *sfp) { kAprTable *self = (kAprTable *) sfp[0].asObject; kArray *arr = (kArray *)KLIB new_kObject(kctx, OnStack, KClass_Array, 0); const apr_array_header_t *apr_arr = apr_table_elts(self->tbl); const apr_table_entry_t *entries = (apr_table_entry_t *)apr_arr->elts; int i=0; for (i=0; i<apr_arr->nelts; i++) { KLIB kArray_Add(kctx, arr, (kAprTableEntry *)KLIB new_kObject(kctx, OnStack, KClass_AprTableEntry, (uintptr_t)entries)); entries++; } KReturn(arr); }
//## @Native @Static Thread Thread.self(); static KMETHOD Thread_self(KonohaContext *kctx, KonohaStack *sfp) { kThread *t = (kThread *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); t->kctx = kctx;//FIXME t->thread = pthread_self(); KReturn(t); }
// @SmartReturn Object Prototype.get(Symbol symbol) static KMETHOD Prototype_get(KonohaContext *kctx, KonohaStack *sfp) { KClass *targetClass = KGetReturnType(sfp); DBG_P("requesting type=%s", KClass_text(targetClass)); ksymbol_t symbol = sfp[1].intValue; KKeyValue *kvs = KLIB kObjectProto_GetKeyValue(kctx, sfp[0].asObject, symbol); if(kvs != NULL) { KClass *c = KClass_(kvs->attrTypeId); if(targetClass == c) { if(KClass_Is(UnboxType, targetClass)) { KReturnUnboxValue(kvs->unboxValue); } else { KReturnField(kvs->ObjectValue); } } DBG_P("requesting type=%s instanceof %s ? %d", KClass_text(c), KClass_text(targetClass), c->isSubType(kctx, c, targetClass)); if(c->isSubType(kctx, c, targetClass)) { if(KClass_Is(UnboxType, c)) { if(KClass_Is(UnboxType, targetClass)) { KReturnUnboxValue(kvs->unboxValue); } else { DBG_P("boxing type=%s instanceof %s ? %d", KClass_text(c), KClass_text(targetClass), c->isSubType(kctx, c, targetClass)); KReturn(KLIB new_kObject(kctx, OnStack, c, kvs->unboxValue)); } } KReturnField(kvs->ObjectValue); } } KReturnUnboxValue(0); // return default value }
static void MPIData_extend(KonohaContext *kctx, kMPIData *p, int size) { size_t newSize = p->offset + size; if(p->size < newSize) { switch(p->typeId) { case KMPI_BYTES: { kBytes *b = (kBytes *)KLIB new_kObject(kctx, OnField, KClass_Bytes, (uintptr_t)newSize); memcpy(b->buf, p->b->buf, p->size); p->b = b; p->size = newSize; break; } case KMPI_FARRAY: { kfloat_t *fa = KCalloc_UNTRACE(sizeof(kfloat_t), newSize); memcpy(fa, p->fa, p->size * sizeof(kfloat_t)); KFree(p->fa, p->size * sizeof(kfloat_t)); p->fa = fa; p->size = newSize; break; } case KMPI_IARRAY: { kint_t *ia = KCalloc_UNTRACE(sizeof(kint_t), newSize); memcpy(ia, p->ia, p->size * sizeof(kint_t)); KFree(p->ia, p->size * sizeof(kint_t)); p->ia = ia; p->size = newSize; break; } default: abort(); } } }
//## @Const method String[] String.split(RegExp regex); static KMETHOD String_split(KonohaContext *kctx, KonohaStack *sfp) { INIT_GCSTACK(); kArray *resultArray = (kArray *)KLIB new_kObject(kctx, _GcStack, KGetReturnType(sfp), 0); kArray_split(kctx, resultArray, sfp[0].asString, sfp[1].asRegExp, S_size(sfp[0].asString)); KReturnWith(resultArray, RESET_GCSTACK()); }
// PoolPlugin Response.create(Event ev); static KMETHOD Response_create(KonohaContext *kctx, KonohaStack *sfp) { struct pool_plugin_response *p = POOL_PLUGIN_CLONE(pool_plugin_response); kRawPtr *ret = (kRawPtr *) KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)p); kRawPtr *ev = (kRawPtr *) sfp[1].asObject; p->bev = ev->rawptr; RETURN_(ret); }
// PoolPlugin React.create(String traceName, String key); static KMETHOD React_create(KonohaContext *kctx, KonohaStack *sfp) { struct pool_plugin_react *p = POOL_PLUGIN_CLONE(pool_plugin_react); kRawPtr *ret = (kRawPtr *) KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)p); p->conf.traceName = copy_string(kctx, sfp[1].asString); p->conf.key = copy_string(kctx, sfp[2].s); RETURN_(ret); }
// PoolPlugin KeyFilter.create(String key); static KMETHOD KeyFilter_create(KonohaContext *kctx, KonohaStack *sfp) { struct pool_plugin_key_filter *p = POOL_PLUGIN_CLONE(pool_plugin_key_filter); kRawPtr *ret = (kRawPtr *) KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)p); p->klen = S_size(sfp[1].asString); p->key = copy_string(kctx, sfp[2].s); RETURN_(ret); }
//## @Const method String[] String.split(RegExp regex, Int limit); static KMETHOD String_splitWithLimit(KonohaContext *kctx, KonohaStack *sfp) { INIT_GCSTACK(); size_t limit = sfp[2].intValue < 0 ? S_size(sfp[0].asString) : (size_t) sfp[2].intValue; kArray *resultArray = (kArray *)KLIB new_kObject(kctx, _GcStack, KGetReturnType(sfp), 0); kArray_split(kctx, resultArray, sfp[0].asString, sfp[1].asRegExp, limit); KReturnWith(resultArray, RESET_GCSTACK()); }
static KMETHOD String_toIterator(KonohaContext *kctx, KonohaStack *sfp) { kIterator *itr = (kIterator *)KLIB new_kObject(kctx, OnStack, CT_StringIterator, 0); KFieldSet(itr, itr->source, sfp[0].asObject); itr->hasNext = String_hasNext; itr->setNextResult = String_setNextResult; KReturn(itr); }
// MecabNode Tagger.ParseToNode(String input) static KMETHOD Tagger_ParseToNode(KonohaContext *kctx, KonohaStack *sfp) { struct _kTagger *mecab = (struct _kTagger *)sfp[0].asObject; const char *input = kString_text(sfp[1].asString); const mecab_node_t* node = mecab_sparse_tonode(mecab->mecab, input); struct _kMecabNode* ret = (struct _kMecabNode *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); ret->node = node; KReturn(ret); }
//## Complex Complex.conjl(); static KMETHOD Complex_conjl(KonohaContext *kctx, KonohaStack *sfp) { kComplex *kc = (kComplex *) sfp[0].asObject; long double _Complex zl = (long double _Complex)kc->z; long double answer = conj(zl); kComplex *ret = (kComplex *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); ret->z = answer; KReturn(ret); }
//## Complex Complex.conjf(); static KMETHOD Complex_conjf(KonohaContext *kctx, KonohaStack *sfp) { kComplex *kc = (kComplex *) sfp[0].asObject; float _Complex zf = (float _Complex)kc->z; float _Complex answer = conj(zf); kComplex *ret = (kComplex *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); ret->z = answer; KReturn(ret); }
// PoolPlugin Statics.create(Func initFo, Func exitFo, Func func); static KMETHOD Statics_create(KonohaContext *kctx, KonohaStack *sfp) { struct pool_plugin_statics *p = POOL_PLUGIN_CLONE(pool_plugin_statics); kRawPtr *ret = (kRawPtr *) KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)p); p->context = (uintptr_t)statics_init(kctx, sfp[1].asFunc, sfp[2].asFunc, sfp[3].asFunc); p->finit = p_init; p->fexit = p_exit; p->function = p_func; RETURN_(ret); }
// PoolPlugin Timer.create(int timer, int startFlat, int contFlat, int finFlag); static KMETHOD Timer_create(KonohaContext *kctx, KonohaStack *sfp) { struct pool_plugin_timer *p = POOL_PLUGIN_CLONE(pool_plugin_timer); kRawPtr *ret = (kRawPtr *) KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)p); p->timer = sfp[1].intValue; p->flag_start = sfp[2].intValue; p->flag_cont = sfp[3].intValue; p->flag_finish = sfp[4].intValue; RETURN_(ret); }
static KMETHOD Array_toIterator(KonohaContext *kctx, KonohaStack *sfp) { kArray *a = sfp[0].asArray; KClass *cIterator = KClass_p0(kctx, KClass_Iterator, kObject_class(a)->p0); kIterator *itr = (kIterator *)KLIB new_kObject(kctx, OnStack, cIterator, 0); KFieldSet(itr, itr->arrayList, a); itr->hasNext = Array_hasNext; itr->setNextResult = KType_Is(UnboxType, kObject_class(a)->p0) ? Array_SetNextResultUnbox : Array_SetNextResult; KReturn(itr); }
static KMETHOD Array_toIterator(KonohaContext *kctx, KonohaStack *sfp) { kArray *a = sfp[0].asArray; KonohaClass *cIterator = CT_p0(kctx, CT_Iterator, O_ct(a)->p0); kIterator *itr = (kIterator *)KLIB new_kObject(kctx, OnStack, cIterator, 0); KFieldSet(itr, itr->arrayList, a); itr->hasNext = Array_hasNext; itr->setNextResult = TY_isUnbox(O_ct(a)->p0) ? Array_setNextResultUnbox : Array_setNextResult; KReturn(itr); }
static kBytes* new_kBytes(KonohaContext *kctx, kArray *gcstack, KClass *c, const char *buf, size_t bufsiz) { kBytes* ba = (kBytes *) KLIB new_kObject(kctx, gcstack, c, bufsiz); if(bufsiz > 0) { ((struct kBytesVar *)ba)->byteptr = (const char *)KCalloc(bufsiz, 1, NULL); ((struct kBytesVar *)ba)->bytesize = bufsiz; memcpy(ba->buf, buf, bufsiz); } return ba; }
// MecabNode MecabNode.bnext() static KMETHOD MecabNode_bnext(KonohaContext *kctx, KonohaStack *sfp) { struct _kMecabNode *node = (struct _kMecabNode *)sfp[0].asObject; mecab_node_t* bnext = node->node->bnext; struct _kMecabNode* ret = NULL; if(node != NULL) { ret = (struct _kMecabNode *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); ret->node = bnext; } KReturn(ret); }
//## Stat System.fstat(int fd) static KMETHOD System_fstat(KonohaContext *kctx, KonohaStack *sfp) { KMakeTrace(trace, sfp); int fd = (int)sfp[1].intValue; struct stat buf = {}; /* zero */ int ret = fstat(fd, &buf); if(ret == -1) { KTraceErrorPoint(trace, SystemFault|SoftwareFault, "fstat", LogInt("fildes", fd), LogErrno); } KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)&buf)); }
//## @Native XmlReader XmlReader.new(String path); static KMETHOD XmlReader_new(KonohaContext *kctx, KonohaStack *sfp) { const char *path = kString_text(sfp[1].asString); xmlTextReaderPtr r = xmlNewTextReaderFilename(path); struct kXmlReaderVar *xml = (struct kXmlReaderVar *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); if(r == NULL) { //kreportf(ErrTag, sfp[K_RTNIDX].uline, "could not create XmlReader Object from %s", path); } xml->reader = (xmlTextReaderPtr)r; KReturn(xml); }
static void KReturnPyObject_(KonohaContext *kctx, KonohaStack *sfp, PyObject *pyo) { if(pyo != NULL) { KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)pyo)); } else { // ERROR if python object is NULL // add ktrace. // looks stupid PyErr_Print(); } }
static void RETURN_PyObject_(KonohaContext *kctx, KonohaStack *sfp, PyObject *pyo) { if(pyo != NULL) { RETURN_(KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), (uintptr_t)pyo)); } else { // ERROR if python object is NULL // add ktrace. // looks stupid PyErr_Print(); } }
//## @Native XmlReader String.convertToXml(); static KMETHOD String_convertToXml(KonohaContext *kctx, KonohaStack *sfp) { xmlChar* input = (xmlChar *)kString_text(sfp[0].asString); xmlTextReaderPtr r = xmlReaderForDoc(input, NULL, NULL, 1); //xmlTextReaderPtr r = xmlReaderForDoc(input, NULL, "UTF-8", 1); struct kXmlReaderVar *xml = (struct kXmlReaderVar *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); if(r == NULL) { //kreportf(ErrTag, sfp[K_RTNIDX].uline, "could not create XmlReader Object from String"); } xml->reader = (xmlTextReaderPtr)r; KReturn(xml); }
//## @Native Thread Thread.create(Func f) static KMETHOD Thread_create(KonohaContext *kctx, KonohaStack *sfp) { INIT_GCSTACK(); kFunc *f = sfp[1].asFunc; KLIB kMethod_DoLazyCompilation(kctx, (f)->mtd, NULL, HatedLazyCompile); kThread *thread = (kThread *)KLIB new_kObject(kctx, _GcStack, KGetReturnType(sfp), 0); thread->rootCtx = kctx; //TODO getRootContext thread->kctx = KLIB KonohaContext_Init(kctx, kctx->platApi); KFieldSet(thread, thread->func, f); pthread_create(&(thread->thread), NULL, spawn_start, thread); RESET_GCSTACK(); // FIXME?? Not sure this is okay?? KReturn(thread); }
//## Log LogPool.get() static KMETHOD LogPool_get(KonohaContext *kctx, KonohaStack *sfp) { logpool_t *lp = (logpool_t *) ((kRawPtr *) sfp[0].asObject)->rawptr; char *buf = malloc(256); char *ret = logpool_client_get(lp, buf, 256); kObject *log = KLIB new_kObject(kctx, O_ct(sfp[K_RTNIDX].o), 0); if (ret == NULL) { kObject_setNullObject(log, 1); free(buf); } RawPtr_init(kctx, log, buf); RETURN_(log); }
//## Stat System.stat(String path) static KMETHOD System_stat(KonohaContext *kctx, KonohaStack *sfp) { KMakeTrace(trace, sfp); char buffer[K_PATHMAX]; kString *path = sfp[1].asString; const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace); struct stat buf = {}; /* zero */ int ret = stat(systemPath, &buf); if(ret == -1) { int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace); KTraceErrorPoint(trace, fault, "stat", LogText("path", kString_text(path)), LogErrno); } KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)&buf)); }
//## ResultSet Connection.query(String query); static KMETHOD Connection_query(KonohaContext *kctx, KonohaStack *sfp) { INIT_GCSTACK(); KMakeTrace(trace, sfp); kConnection *conn = (kConnection *)sfp[0].asObject; const char *query = kString_text(sfp[1].asString); kResultSet *rs = (kResultSet *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)conn); KCursor *qcur = conn->driver->qexec(kctx, conn->db, query, rs, trace); if(qcur != NULL) { rs->qcur = qcur; rs->driver = conn->driver; } KReturnWith(rs, RESET_GCSTACK()); }
// MecabNode MecabNode.enext() static KMETHOD MecabNode_enext(KonohaContext *kctx, KonohaStack *sfp) { struct _kMecabNode *node = (struct _kMecabNode *)sfp[0].asObject; mecab_node_t* enext = node->node->enext; struct _kMecabNode* ret; if(node != NULL) { ret = (struct _kMecabNode *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0); ret->node = enext; KReturn(ret); } else { KReturnDefaultValue(); } }
static void konoha_commandline(CTX, int argc, char** argv) { kclass_t *CT_StringArray0 = CT_p0(_ctx, CT_Array, TY_String); kArray *a = (kArray*)new_kObject(CT_StringArray0, NULL); int i; for(i = 0; i < argc; i++) { DBG_P("argv=%d, '%s'", i, argv[i]); kArray_add(a, new_kString(argv[i], strlen(argv[i]), SPOL_TEXT)); } KDEFINE_OBJECT_CONST ConstData[] = { {"SCRIPT_ARGV", CT_StringArray0->cid, (kObject*)a}, {} }; kNameSpace_loadConstData(KNULL(NameSpace), ConstData, 0); }