//## Json Json.new();
static KMETHOD Json_new (KonohaContext *kctx, KonohaStack *sfp)
{
struct _kJson* json = (struct _kJson *)KLIB new_kObjectDontUseThis(kctx, KGetReturnType(sfp), 0);
json->obj = json_object();
json_incref(json->obj);
KReturn(json);
}
//## @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);
}
//## @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());
}
// @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
}
//## Json Json[].get(int idx);
static KMETHOD JsonArray_get(KonohaContext *kctx, KonohaStack *sfp)
{
kArray *a = sfp[0].asArray;
json_t *ja = (json_t *)a->ObjectItems;
struct _kJson *json = (struct _kJson *)KLIB new_kObjectDontUseThis(kctx, KGetReturnType(sfp), 0);
json->obj = json_array_get(ja, sfp[1].intValue);
KReturn(json);
}
//## @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());
}
//## 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);
}
//## Bytes String.toBytes();
static KMETHOD String_toBytes(KonohaContext *kctx, KonohaStack *sfp)
{
kString* thisString = sfp[0].asString;
size_t size = kString_size(thisString);
if(PLATAPI I18NModule.isSystemCharsetUTF8(kctx)) {
KReturn(new_kBytes(kctx, OnStack, KGetReturnType(sfp), kString_text(thisString), size));
}
else {
KMakeTrace(trace, sfp);
KBuffer wb;
KLIB KBuffer_Init(&(kctx->stack->cwb), &wb);
KBuffer_convertCharset(kctx, &wb, I18NAPI systemCharset, "UTF-8", kString_text(thisString), size, trace);
KReturnWith(
new_kBytes(kctx, OnStack, KGetReturnType(sfp), KLIB KBuffer_text(kctx, &wb, NonZero), KBuffer_bytesize(&wb)),
KLIB KBuffer_Free(&wb)
);
}
}
//## 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);
}
// 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);
}
//## @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);
}
//## 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));
}
// 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);
}
//## @Static Json Json.parse(String str);
static KMETHOD Json_parse(KonohaContext *kctx, KonohaStack *sfp)
{
const char *buf = S_text(sfp[1].asString);
json_t* obj;
json_error_t err;
obj = json_loads(buf, 0, &err);
struct _kJson *ret = (struct _kJson *)KLIB new_kObjectDontUseThis(kctx, KGetReturnType(sfp), 0);
CHECK_JSON(obj, KReturn((kJson *)KLIB Knull(kctx, O_ct(ret))));
obj = json_incref(obj);
ret->obj = obj;
KReturn(ret);
}
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();
}
}
//## @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);
}
//## Json Json.getJson(String key);
static KMETHOD Json_getJson(KonohaContext *kctx, KonohaStack *sfp)
{
json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
CHECK_JSON(obj, KReturn((kJson *)KLIB Knull(kctx, O_ct(sfp[0].asObject))));
const char *key = S_text(sfp[1].asString);
json_t* ret = json_object_get(obj, key);
CHECK_JSON(ret, KReturn((kJson *)KLIB Knull(kctx, O_ct(sfp[0].asObject))));
ret = json_incref(ret);
struct _kJson *json = (struct _kJson *)KLIB new_kObjectDontUseThis(kctx, KGetReturnType(sfp), 0);
json->obj = ret;
KReturn(json);
}
// @SmartReturn Object Object.as(Object target)
static KMETHOD Object_as(KonohaContext *kctx, KonohaStack *sfp)
{
KonohaClass *selfClass = O_ct(sfp[0].asObject), *targetClass = KGetReturnType(sfp);
kObject *returnValue;
if(selfClass == targetClass || selfClass->isSubType(kctx, selfClass, targetClass)) {
returnValue = sfp[0].asObject;
}
else {
returnValue = KLIB Knull(kctx, targetClass);
}
sfp[K_RTNIDX].unboxValue = O_unbox(returnValue);
KReturn(returnValue);
}
//## @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);
}
//## 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();
}
}
//## 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));
}
//## @SmartReturn Object ResultSet.get(String n);
static KMETHOD ResultSet_get(KonohaContext *kctx, KonohaStack *sfp)
{
KClass *retClass = KGetReturnType(sfp);
if(retClass->typeId == KType_Int) {
ResultSet_getInt(kctx, sfp);
} else if(retClass->typeId == KType_String) {
ResultSet_getString(kctx, sfp);
} else if(KDefinedKonohaCommonModule() && retClass->typeId == KType_float) {
ResultSet_getFloat(kctx, sfp);
} else {
kObject *returnValue = KLIB Knull(kctx, retClass);
KStackSetUnboxValue(sfp[K_RTNIDX].unboxValue, kObject_Unbox(returnValue));
KReturn(returnValue);
}
}
//## Prototype Prototype.(Object o);
static KMETHOD Prototype_(KonohaContext *kctx, KonohaStack *sfp)
{
ksymbol_t symbol = KDynamicCallSymbol(sfp);
KKeyValue *kvs = KLIB kObjectProto_GetKeyValue(kctx, sfp[0].asObject, symbol);
if(kvs != NULL) {
KClass *c = KClass_(kvs->attrTypeId);
kParam *cparam = KClass_cparam(c);
if(KClass_isFunc(c) && cparam->psize <= KDynamicCallArgument(sfp)) {
KClass *thisClass = kObject_class(sfp[0].asObject), *returnType = KGetReturnType(sfp);
kFunc *fo = (kFunc *)kvs->FuncValue;
KStackSetFunc(sfp, fo);
KStackDynamicTypeCheck(kctx, sfp, fo->method, thisClass);
KStackCall(sfp);
KStackReturnTypeCheck(kctx, sfp, fo->method, thisClass, returnType);
}
}
}
//## DIR System.opendir(String path)
static KMETHOD System_opendir(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);
DIR *d = opendir(systemPath);
if(d == NULL) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "opendir", LogText("dirname", kString_text(path)), LogErrno);
KLIB KRuntime_raise(kctx, KException_("IO"), fault, NULL, sfp);
}
kDir *dir = (kDir *)KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)d);
KFieldSet(dir, dir->PathInfoNULL, path);
if(!PLATAPI I18NModule.isSystemCharsetUTF8(kctx)) {
dir->readerIconv = PLATAPI I18NModule.iconvSystemCharsetToUTF8(kctx, trace);
}
KReturn(dir);
}
//## Konoha KonohaFactory.create();
static KMETHOD KonohaFactory_create(KonohaContext *kctx, KonohaStack *sfp)
{
kKonohaFactory *f = (kKonohaFactory *)sfp[0].asObject;
KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), (uintptr_t)f->factory));
}
static KMETHOD KonohaFactory_new(KonohaContext *kctx, KonohaStack *sfp)
{
KReturn(KLIB new_kObject(kctx, OnStack, KGetReturnType(sfp), 0));
}
static kJSON *NewJsonObject(KonohaContext *kctx, KonohaStack *sfp, JSON val)
{
kJSON *json = (kJSON *)KLIB new_kObjectDontUseThis(kctx, KGetReturnType(sfp), 0);
json->json = val;
return json;
}
