static kbool_t process_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
kparamtype_t p = {KType_Int};
KClass *cintArray = KLIB KClass_Generics(kctx, KClass_(KType_Array), KType_void, 1, &p);
#define KType_IntArray (cintArray->typeId)
KDEFINE_METHOD MethodData[] = {
_Public|_Static, _F(System_getpid), KType_Int, KType_System, KMethodName_("getpid"), 0,
_Public|_Static, _F(System_getppid), KType_Int, KType_System, KMethodName_("getppid"), 0,
_Public|_Static, _F(System_getuid), KType_Int, KType_System, KMethodName_("getuid"), 0,
_Public|_Static, _F(System_geteuid), KType_Int, KType_System, KMethodName_("geteuid"), 0,
_Public|_Static, _F(System_getgid), KType_Int, KType_System, KMethodName_("getgid"), 0,
_Public|_Static, _F(System_getegid), KType_Int, KType_System, KMethodName_("getegid"), 0,
_Public|_Static, _F(System_getpgid), KType_Int, KType_System, KMethodName_("getpgid"), 1, KType_Int, KFieldName_("pid"),
_Public|_Static, _F(System_Setpgid), KType_Int, KType_System, KMethodName_("setpgid"), 2, KType_Int, KFieldName_("pid"), KType_Int, KFieldName_("pgid"),
_Public|_Static, _F(System_getpriority), KType_Int, KType_System, KMethodName_("getpriority"), 2, KType_Int, KFieldName_("which"), KType_Int, KFieldName_("who"),
_Public|_Static, _F(System_Setpriority), KType_Int, KType_System, KMethodName_("setpriority"), 3, KType_Int, KFieldName_("which"), KType_Int, KFieldName_("who"), KType_Int, KFieldName_("priority"),
_Public|_Static, _F(System_getgroups), KType_Int, KType_System, KMethodName_("getgroups"), 2, KType_Int, KFieldName_("size"), KType_IntArray, KFieldName_("list[]"),
_Public|_Static, _F(System_Setgroups), KType_Int, KType_System, KMethodName_("setgroups"), 2, KType_Int, KFieldName_("size"), KType_IntArray, KFieldName_("*list"),
_Public|_Static, _F(System_fork), KType_Int, KType_System, KMethodName_("fork"), 0,
_Public|_Static, _F(System_wait), KType_Int, KType_System, KMethodName_("wait"), 0,
_Public|_Static, _F(System_waitpid), KType_Int, KType_System, KMethodName_("wait"), 2, KType_Int, KFieldName_("pid"), KType_Int, KFieldName_("options"),
_Public|_Static, _F(System_Setuid), KType_Int, KType_System, KMethodName_("setuid"), 1, KType_Int, KFieldName_("uid"),
_Public|_Static, _F(System_Seteuid), KType_Int, KType_System, KMethodName_("seteuid"), 1, KType_Int, KFieldName_("euid"),
_Public|_Static, _F(System_Setreuid), KType_Int, KType_System, KMethodName_("setreuid"), 2, KType_Int, KFieldName_("ruid"), KType_Int, KFieldName_("euid"),
_Public|_Static, _F(System_Setgid), KType_Int, KType_System, KMethodName_("setgid"), 1, KType_Int, KFieldName_("gid"),
_Public|_Static, _F(System_Setegid), KType_Int, KType_System, KMethodName_("setguid"), 1, KType_Int, KFieldName_("egid"),
_Public|_Static, _F(System_Setregid), KType_Int, KType_System, KMethodName_("setrguid"), 2, KType_Int, KFieldName_("rgid"), KType_Int, KFieldName_("egid"),
_Public|_Static, _F(System_Setsid), KType_Int, KType_System, KMethodName_("setsid"), 0,
_Public|_Static, _F(System_getsid), KType_Int, KType_System, KMethodName_("getsid"), 1, KType_Int, KFieldName_("pid"),
_Public|_Static, _F(System_sleep), KType_Int, KType_System, KMethodName_("sleep"), 1, KType_Int, KFieldName_("sec"),
_Public|_Static, _F(System_usleep), KType_Boolean, KType_System, KMethodName_("usleep"), 1, KType_Int, KFieldName_("usec"),
_Public|_Static, _F(System_system), KType_Int, KType_System, KMethodName_("system"), 1, KType_String, KFieldName_("command"),
_Public|_Static, _F(System_getenv), KType_String, KType_System, KMethodName_("getenv"), 1, KType_String, KFieldName_("name"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST intData[] = {
{KDefineConstInt(SIGHUP)},
{KDefineConstInt(SIGINT)},
{KDefineConstInt(SIGABRT)},
{KDefineConstInt(SIGKILL)},
/*for System.setpriority*/
{KDefineConstInt(PRIO_PROCESS)},
{KDefineConstInt(PRIO_PGRP)},
{KDefineConstInt(PRIO_USER)},
{}
};
KLIB kNameSpace_LoadConstData(kctx, ns, KConst_(intData), trace);
return true;
}
static KClass *CreateEnvClass(KonohaContext *kctx, kNameSpace *ns, kToken *typeTk, KClass **EnvObjectClass)
{
INIT_GCSTACK();
size_t i = 0, esize = ns->genv->localScope.varsize;
size_t start = 0, end = esize;
KGammaStackDecl *oldenv = ns->genv->localScope.varItems;
kparamtype_t *p = ALLOCA(kparamtype_t, esize);
char buf[256] = {'_', '_', '_', 'E', 'N', 'V', 0}, *text = buf + 6;
if(ns->genv->thisClass == KClass_NameSpace) {
start = 1;
end = esize - 1;
}
assert(end < 256);
for(i = start; i <= end; i++) {
p[i-1].name = oldenv[i].name;
p[i-1].attrTypeId = oldenv[i].attrTypeId;
*(text++) = (KType_text(p[i-1].attrTypeId))[0];
}
*EnvObjectClass = KLIB kNameSpace_GetClassByFullName(kctx, ns, buf, text - buf, NULL);
if(*EnvObjectClass == NULL) {
*EnvObjectClass = kNameSpace_DefineClassName(kctx, ns, buf, text - buf);
}
KClass *ct = KLIB KClass_Generics(kctx, KClass_Func, typeTk->resolvedTypeId, end, p);
if(end >= 1) {
((KClassVar *)ct)->classMethodList = new_(MethodArray, end*2, OnGlobalConstList);
for(i = start; i <= end; i++) {
int n = i - 1;
ksymbol_t sym = p[n].name;
ktypeattr_t type = KTypeAttr_Unmask(p[n].attrTypeId);
kMethod *getter = new_FunctionGetter(kctx, _GcStack, ct->typeId, sym, type, n);
kMethod *setter = new_FunctionSetter(kctx, _GcStack, ct->typeId, sym, type, n);
KLIB kArray_Add(kctx, ct->classMethodList, getter);
KLIB kArray_Add(kctx, ct->classMethodList, setter);
}
}
RESET_GCSTACK();
return ct;
}
static kbool_t Libevent_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
/* If you want to create Generic class like Array<T>, see konoha.map package */
// cevent_base
KDEFINE_CLASS defcevent_base = {0};
SETSTRUCTNAME(defcevent_base, cevent_base);
defcevent_base.cflag = KClassFlag_Final; //must be final in C
defcevent_base.init = cevent_base_Init;
defcevent_base.free = cevent_base_Free;
KClass *cevent_baseClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcevent_base, trace);
// cevent
KDEFINE_CLASS defcevent = {0};
SETSTRUCTNAME(defcevent, cevent);
defcevent.cflag = KClassFlag_Final;
defcevent.init = cevent_Init;
// defcevent.reftrace = cevent_Reftrace;
defcevent.free = cevent_Free;
KClass *ceventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcevent, trace);
// cbufferevent
KDEFINE_CLASS defcbufferevent = {0};
SETSTRUCTNAME(defcbufferevent, cbufferevent);
defcbufferevent.cflag = KClassFlag_Final;
defcbufferevent.init = cbufferevent_Init;
// defcbufferevent.reftrace = cbufferevent_Reftrace;
defcbufferevent.free = cbufferevent_Free;
KClass *cbuffereventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcbufferevent, trace);
// eventCBArg
KDEFINE_CLASS defeventCBArg = {0};
SETSTRUCTNAME(defeventCBArg, eventCBArg);
defeventCBArg.cflag = KClassFlag_Final;
defeventCBArg.init = eventCBArg_Init;
defeventCBArg.reftrace = eventCBArg_Reftrace;
defeventCBArg.free = eventCBArg_Free;
KClass *eventCBArgClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defeventCBArg, trace);
// buffereventCBArg
KDEFINE_CLASS defbuffereventCBArg = {0};
SETSTRUCTNAME(defbuffereventCBArg, buffereventCBArg);
defbuffereventCBArg.cflag = KClassFlag_Final;
defbuffereventCBArg.init = buffereventCBArg_Init;
defbuffereventCBArg.reftrace = buffereventCBArg_Reftrace;
defbuffereventCBArg.free = buffereventCBArg_Free;
KClass *buffereventCBArgClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defbuffereventCBArg, trace);
// ctimeval
KDEFINE_CLASS defctimeval = {0};
SETSTRUCTNAME(defctimeval, ctimeval);
defctimeval.cflag = KClassFlag_Final;
defctimeval.init = ctimeval_Init;
KClass *ctimevalClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defctimeval, trace);
// Sockaddr_in
KDEFINE_CLASS defSockaddr_in = {0};
SETSTRUCTNAME(defSockaddr_in, Sockaddr_in);
defSockaddr_in.cflag = KClassFlag_Final;
defSockaddr_in.init = Sockaddr_in_Init;
KClass *Sockaddr_inClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defSockaddr_in, trace);
/* You can define methods with the following procedures. */
int KType_cevent_base = cevent_baseClass->typeId;
int KType_cevent = ceventClass->typeId;
int KType_cbufferevent = cbuffereventClass->typeId;
int KType_eventCBArg = eventCBArgClass->typeId;
int KType_buffereventCBArg = buffereventCBArgClass->typeId;
int KType_ctimeval = ctimevalClass->typeId;
int KType_Sockaddr_in = Sockaddr_inClass->typeId;
/* define Generics parameter for callback method */
//eventCB_p
kparamtype_t eventCB_p[] = {{KType_Int, 0}, {KType_Int, 0}, {KType_Object, 0}};
KClass *ceventCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 3, eventCB_p);
int KType_ceventCBfunc = ceventCBfunc->typeId;
//bev_dataCB_p
kparamtype_t bev_dataCB_p[] = {{KType_cbufferevent, 0}, {KType_Object, 0}};
KClass *Cbev_dataCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 2, bev_dataCB_p);
int KType_Cbev_dataCBfunc = Cbev_dataCBfunc->typeId;
//bev_eventCB_p
kparamtype_t bev_eventCB_p[] = {{KType_cbufferevent, 0}, {KType_Int, 0}, {KType_Object, 0}};
KClass *Cbev_eventCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 3, bev_eventCB_p);
int KType_Cbev_eventCBfunc = Cbev_eventCBfunc->typeId;
KDEFINE_METHOD MethodData[] = {
// System class
_Public|_Static, _F(System_evutil_make_socket_nonblocking), KType_Int, KType_System, KMethodName_("evutil_make_socket_nonblocking"), 1, KType_Int, KFieldName_("fd"),
// cevent_base
_Public, _F(cevent_base_new), KType_cevent_base, KType_cevent_base, KMethodName_("new"), 0,
_Public, _F(cevent_base_event_dispatch), KType_Int, KType_cevent_base, KMethodName_("event_dispatch"), 0,
// cevent
_Public, _F(cevent_new), KType_cevent, KType_cevent, KMethodName_("new"), 4, KType_cevent_base, KFieldName_("cevent_base"), KType_Int, KFieldName_("evd"), KType_Int, KFieldName_("event"), KType_eventCBArg, KFieldName_("CBarg"),
_Public, _F(cevent_event_add), KType_Int, KType_cevent, KMethodName_("event_add"), 1, KType_ctimeval, KFieldName_("timeval"),
_Public, _F(cevent_event_del), KType_Int, KType_cevent, KMethodName_("event_del"), 0,
_Public, _F(cevent_getID), KType_Int, KType_cevent, KMethodName_("getID"), 0,
_Public, _F(cevent_getEvents), KType_Int, KType_cevent, KMethodName_("getEvents"), 0,
// cbufferevent
_Public, _F(cbufferevent_new), KType_cbufferevent, KType_cbufferevent, KMethodName_("new"), 3, KType_cevent_base, KFieldName_("cevent_base"), KType_Int, KFieldName_("evd"), KType_Int, KFieldName_("options"),
_Public, _F(cbufferevent_setcb), KType_void, KType_cbufferevent, KMethodName_("bufferevent_setcb"), 1, KType_buffereventCBArg, KFieldName_("buffereventCBArg"),
_Public, _F(cbufferevent_socket_connect), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_socket_connect"), 1, KType_Sockaddr_in, KFieldName_("sockaddr"),
_Public, _F(cbufferevent_enable), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_enable"), 1, KType_Int, KFieldName_("event"),
_Public, _F(cbufferevent_write), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_write"), 1, KType_Bytes, KFieldName_("writebuffer"),
_Public, _F(cbufferevent_read), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_read"), 1, KType_Bytes, KFieldName_("readbuffer"),
// eventCBArg
_Public, _F(eventCBArg_new), KType_eventCBArg, KType_eventCBArg, KMethodName_("new"), 2, KType_ceventCBfunc, KFieldName_("konoha_CB"), KType_Object, KFieldName_("CBarg"),
// buffereventCBArg
_Public, _F(buffereventCBArg_new), KType_buffereventCBArg, KType_buffereventCBArg, KMethodName_("new"), 4, KType_Cbev_dataCBfunc, KFieldName_("readCB"), KType_Cbev_dataCBfunc, KFieldName_("writeCB"), KType_Cbev_eventCBfunc, KFieldName_("eventCB"), KType_Object, KFieldName_("CBarg"),
// ctimeval
_Public, _F(ctimeval_new), KType_ctimeval, KType_ctimeval, KMethodName_("new"), 2, KType_Int, KFieldName_("tv_sec"), KType_Int, KFieldName_("tv_usec"),
// Sockaddr_in
_Public, _F(Sockaddr_in_new), KType_Sockaddr_in, KType_Sockaddr_in, KMethodName_("new"), 3, KType_Int, KFieldName_("family"), KType_Int, KFieldName_("addr"), KType_Int, KFieldName_("port"),
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST IntData[] = {
// === for event_new() ===
{KDefineConstInt(EV_TIMEOUT)},
{KDefineConstInt(EV_READ)},
{KDefineConstInt(EV_WRITE)},
{KDefineConstInt(EV_SIGNAL)},
{KDefineConstInt(EV_PERSIST)},
{KDefineConstInt(EV_ET)},
// === for bufferevent ===
// bufferevent.h
{KDefineConstInt(BEV_EVENT_READING)},
{KDefineConstInt(BEV_EVENT_WRITING)},
{KDefineConstInt(BEV_EVENT_EOF)},
{KDefineConstInt(BEV_EVENT_ERROR)},
{KDefineConstInt(BEV_EVENT_TIMEOUT)},
{KDefineConstInt(BEV_EVENT_CONNECTED)},
// bufferevent.h: enum bufferevent_options
{KDefineConstInt(BEV_OPT_CLOSE_ON_FREE)},
{KDefineConstInt(BEV_OPT_THREADSAFE)},
{KDefineConstInt(BEV_OPT_DEFER_CALLBACKS)},
{KDefineConstInt(BEV_OPT_UNLOCK_CALLBACKS)},
{KDefineConstInt(AF_INET)},// TODO should be implement in posix.socket package
{} /* <= sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KConst_(IntData), trace);
return true;
}
#define KType_SockAddr cSockAddr->typeId
#define KDefineConstInt(T) #T, KType_Int, T
static kbool_t socket_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_CLASS defSockAddr = {
STRUCTNAME(SockAddr),
.cflag = KClassFlag_Final,
.init = SockAddr_Init,
.free = SockAddr_Free,
};
KClass *cSockAddr = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defSockAddr, trace);
kparamtype_t pi = {KType_Int, KFieldName_("intValue")};
KClass *KClass_IntArray = KLIB KClass_Generics(kctx, KClass_Array, KType_Int, 1, &pi);
ktypeattr_t KType_IntArray = KClass_IntArray->typeId;
KDEFINE_METHOD MethodData[] = {
_Public|_Static|_Const|_Im, _F(System_accept), KType_Int, KType_System, KMethodName_("accept"), 2, KType_Int, KFieldName_("fd"), KType_SockAddr, KFieldName_("sockaddr"),
_Public|_Static|_Const|_Im, _F(System_bind), KType_Int, KType_System, KMethodName_("bind"), 4, KType_Int, KFieldName_("fd"), KType_String, KFieldName_("srcIP"), KType_Int, KFieldName_("srcPort"), KType_Int, KFieldName_("family"),
_Public|_Static|_Const|_Im, _F(System_close), KType_Int, KType_System, KMethodName_("close"), 1, KType_Int, KFieldName_("fd"),
_Public|_Static|_Const|_Im, _F(System_connect), KType_Int, KType_System, KMethodName_("connect"), 4, KType_Int, KFieldName_("fd"), KType_String, KFieldName_("dstIP"), KType_Int, KFieldName_("dstPort"), KType_Int, KFieldName_("family"),
_Public|_Static|_Const|_Im, _F(System_listen), KType_Int, KType_System, KMethodName_("listen"), 2, KType_Int, KFieldName_("fd"), KType_Int, KFieldName_("backlog"),
// _Public|_Static|_Const|_Im, _F(System_getsockname), KType_Map KType_System, KMethodName_("getsockname"),1, KType_Int, KFieldName_("fd"),
_Public|_Static|_Const|_Im, _F(System_getsockopt), KType_Int, KType_System, KMethodName_("getsockopt"), 2, KType_Int, KFieldName_("fd"), KType_Int, KFieldName_("opt"),
_Public|_Static|_Const|_Im, _F(System_Setsockopt), KType_Int, KType_System, KMethodName_("setsockopt"), 3, KType_Int, KFieldName_("fd"), KType_Int, KFieldName_("opt"), KType_Int, KFieldName_("value"),
// _Public|_Static|_Const|_Im, _F(System_getpeername), KType_Map, KType_System, KMethodName_("getpeername"), 1, KType_Int, KFieldName_("fd"),
// _Public|_Static, _F(System_Select), KType_Int, KType_System, KMethodName_("select"), 5, KType_IntArray, KFieldName_("readsocks"), KType_IntArray, KFieldName_("writesocks"), KType_IntArray, KFieldName_("exceptsocks"), KType_Int, KFieldName_("timeoutSec"), KType_Int, KFieldName_("timeoutUSec"),
_Public|_Static|_Const|_Im, _F(System_shutdown), KType_Int, KType_System, KMethodName_("shutdown"), 2, KType_Int, KFieldName_("fd"), KType_Int, KFieldName_("how"),
_Public|_Static|_Const|_Im, _F(System_sockatmark), KType_Int, KType_System, KMethodName_("sockatmark"), 1, KType_Int, KFieldName_("fd"),
