static kcontext_t* new_hcontext(CTX ctx0)
{
kcontext_t *ctx;
static volatile size_t ctxid_counter = 0;
if(ctx0 == NULL) {
ctxid_counter = 0;
ctx = (kcontext_t*)malloc(sizeof(kcontext_t));
knh_bzero(ctx, sizeof(kcontext_t));
}
else {
KNH_ASSERT_CTX0(ctx0);
ctx = (kcontext_t*)KNH_MALLOC(ctx0, sizeof(kcontext_t));
knh_bzero(ctx, sizeof(kcontext_t));
}
ctx->flag = 0;
ctx->ctxid = ctxid_counter;
ctxid_counter++;
// ctx->freeObjectList = NULL;
// ctx->freeMemoryList = NULL;
ctx->parent = ctx;
ctx->api2 = getapi2();
{
kuintptr_t i = 0, ch;
kuint_t t = knh_rand();
ch = t % 26;
ctx->trace[i] = 'A' + ch;
for(i = 1; i < 9; i++) {
t = t / 36;
if (t == 0) t = knh_rand();
ch = t % 36;
ctx->trace[i] = (ch < 10) ? '0' + ch : 'A' + (ch - 10);
}
}
ctx->seq = 0;
ctx->ctxobjNC = NULL;
if(ctx0 == NULL) {
const char *ptrace = knh_getenv(K_DEOS_TRACE);
if(ptrace == NULL) {
ptrace = "$(setenv " K_DEOS_TRACE ")";
}
KNH_NTRACE2(ctx, "konoha:newtrace", K_NOTICE, KNH_LDATA(
LOG_s("parent", ptrace)
#if defined(K_USING_POSIX_)
, LOG_u("ppid", getppid())
#endif /* !defined(K_USING_POSIX_) */
));
}
else {
KNH_NTRACE2(ctx, "konoha:newtrace", K_NOTICE, KNH_LDATA(LOG_s("parent", ctx0->trace), LOG_u("seq", ctx0->seq)));
}
return ctx;
}
void knh_Bytes_unputc(knh_Bytes_t *ba, int c)
{
if(BA_size(ba) >= c) {
BA_size(ba) -= c;
knh_bzero(ba->bu.ubuf + BA_size(ba), c);
}
}
void knh_Bytes_clear(knh_Bytes_t *ba, size_t pos)
{
if(pos < BA_size(ba)) {
knh_bzero(ba->bu.ubuf + pos, BA_size(ba) - pos);
BA_size(ba) = pos;
}
}
void knh_Bytes_clear(knh_Bytes_t *ba, size_t pos)
{
DBG_ASSERT(!knh_Bytes_isStatic(ba));
if(pos < BA_size(ba)) {
knh_bzero(ba->bu.ubuf + pos, BA_size(ba) - pos);
BA_size(ba) = pos;
}
}
void knh_EventTBL_expand(CTX)
{
size_t s = ctx->share->sizeEventTBL, max = ctx->share->capacityEventTBL * 2;
knh_EventTBL_t *newt = (knh_EventTBL_t*)KCALLOC(SIZEOF_TEXPT(max));
knh_bzero(newt, SIZEOF_TEXPT(max));
knh_memcpy(newt, ctx->share->EventTBL, SIZEOF_TEXPT(s));
((kshare_t*)ctx->share)->EventTBL = newt;
((kshare_t*)ctx->share)->capacityEventTBL = max;
}
kmutex_t *knh_mutex_malloc(CTX)
{
kmutex_t *m = (kmutex_t*)malloc(sizeof(kmutex_t));
knh_bzero(m, sizeof(kmutex_t));
if(knh_mutex_init(m) != 0) {
KNH_NTRACE2(_ctx, "mutex_init", K_PERROR, KNH_LDATA(LOG_p("mutex", m)));
}
return m;
}
static knh_map_t *hmap_init(CTX ctx, size_t init, const char *path, void *option)
{
knh_hmap_t *hmap = (knh_hmap_t*)KNH_MALLOC(ctx, sizeof(knh_hmap_t));
knh_bzero(hmap, sizeof(knh_hmap_t));
if(init < K_HASH_INITSIZE) init = K_HASH_INITSIZE;
hmap->hentry = (knh_hentry_t**)KNH_REALLOC(ctx, hmap->DBGNAME, NULL, 0, init, sizeof(knh_hentry_t*));
hmap->hmax = init;
hmap->size = 0;
hmap->factor = KNH_HASH_FACTOR(hmap->hmax);
return (knh_map_t*)hmap;
}
void knh_Array_clear(CTX ctx, kArray *a, size_t n)
{
if(!Array_isNDATA(a)) {
#ifdef K_USING_RCGC
size_t i;
for(i = n; i < a->size; i++) {
KNH_FINALv(ctx, a->list[i]);
}
#else
knh_bzero(a->list + n, sizeof(void*) * (a->size - n));
#endif
}
a->size = n;
}
static void knh_Bytes_expands(Ctx *ctx, knh_Bytes_t *ba, size_t newsize)
{
if(ba->capacity == 0) {
newsize = knh_good_size(newsize);
ba->bu.ubuf = (knh_uchar_t*)KNH_MALLOC(ctx, newsize);
ba->capacity = newsize;
}
else {
knh_uchar_t *buf = ba->bu.ubuf;
size_t capacity = ba->capacity;
knh_uchar_t *newa = (knh_uchar_t*)KNH_MALLOC(ctx, newsize);
knh_memcpy(newa, buf, capacity);
knh_bzero(&newa[capacity], newsize - capacity);
ba->bu.ubuf = newa;
ba->capacity = newsize;
KNH_FREE(ctx, buf, capacity);
if(unlikely(ctx->bufa == ba)) {
KNH_SYSLOG(ctx, LOG_INFO, "ExtendedContextBuffer", "*newsize=%ld, pointer=(%p => %p)", newsize, buf, newa);
knh_Bytes_checkstack(ctx, buf, buf + ba->bu.len, newa);
}
}
}
static kcontext_t* new_RootContext(void)
{
kcontext_t *ctx = (kcontext_t*)new_hcontext(NULL);
const knh_LoaderAPI_t *kapi = knh_getLoaderAPI();
kshare_t *share = (kshare_t*)malloc(sizeof(kshare_t) + sizeof(kstatinfo_t) + sizeof(knh_ServiceSPI_t));
ctx->share = share;
knh_bzero(share, sizeof(kshare_t) + sizeof(kstatinfo_t) + sizeof(knh_ServiceSPI_t));
share->syslock = knh_mutex_malloc(_ctx);
ctx->stat = (kstatinfo_t*)((share+1));
ctx->spi = (const knh_ServiceSPI_t*)(_ctx->stat + 1);
initServiceSPI((knh_ServiceSPI_t*)ctx->spi);
kmemshare_init(_ctx);
share->ClassTBL = (kclass_t**)KMALLOC((CTX)ctx, sizeof(struct _kclass*)*(K_CLASSTABLE_INIT));
knh_bzero(share->ClassTBL, sizeof(struct _kclass*)*(K_CLASSTABLE_INIT));
share->sizeClassTBL = 0;
share->capacityClassTBL = K_CLASSTABLE_INIT;
share->EventTBL = (knh_EventTBL_t*)KCALLOC(SIZEOF_TEXPT(K_EVENTTBL_INIT));
knh_bzero((void*)share->EventTBL, SIZEOF_TEXPT(K_EVENTTBL_INIT));
share->sizeEventTBL = 0;
share->capacityEventTBL = K_EVENTTBL_INIT;
kshare_loadStructData(_ctx, kapi);
KINITv(share->funcDictSet, new_DictSet0(_ctx, 0, 0, "funcDictSet"));
KINITv(share->constPtrMap, new_PtrMap(_ctx, 0));
KINITv(share->inferPtrMap, new_PtrMap(_ctx, 0));
KINITv(share->xdataPtrMap, new_PtrMap(_ctx, 0));
KINITv(share->constPools, new_Array0(_ctx, 0));
knh_loadSystemTypeMapRule(_ctx);
knh_ClassTBL_setConstPool(_ctx, ClassTBL(CLASS_Int));
knh_ClassTBL_setConstPool(_ctx, ClassTBL(CLASS_Float));
#ifdef K_USING_STRINGPOOL
knh_ClassTBL_setConstPool(_ctx, ClassTBL(CLASS_String));
#endif
{
kObject *p = (kObject*)new_hObject_(_ctx, ClassTBL(CLASS_Object));
Object_setNullObject(p, 1);
KINITv(share->constNull, p);
}
{
kBoolean *o = new_H(Boolean);
o->n.bvalue = 1;
KINITv(share->constTrue, o);
o = new_H(Boolean);
o->n.bvalue = 0;
KINITv(share->constFalse, o);
}
{
static const kdim_t dimINIT = {};
kArray *a = new_H(Array);
(a)->size = 0;
(a)->dim = &dimINIT;
KINITv(share->emptyArray, a);
}
share->tString = (kString**)KCALLOC(SIZEOF_TSTRING);
knh_bzero(share->tString, SIZEOF_TSTRING);
knh_loadScriptSystemString(_ctx);
KINITv(share->cwdPath, new_CurrentPath(_ctx));
/* These are not shared, but needed to initialize System*/
knh_stack_initexpand(_ctx, NULL, K_STACKSIZE);
KINITv(share->packageDictMap, new_DictMap0(_ctx, 0, 1/*isCaseMap*/, "packageDictMap"));
KINITv(share->secfileidtyDictMap, new_DictMap0(_ctx, 0, 1/*isCaseMap*/, "secfileidtyDictMap")); // added by Wakamori
KINITv(share->classNameDictSet, new_DictSet0(_ctx, 128, 1/*isCaseMap*/, "classNameDictSet"));
KINITv(share->eventDictSet, new_DictSet0(_ctx, 32, 1/*isCaseMap*/, "eventDictSet"));
KINITv(share->streamDpiDictSet, new_DictSet0(_ctx, 0, 1/*isCaseMap*/, "streamDpiDictSet"));
KINITv(share->mapDpiDictSet, new_DictSet0(_ctx, 0, 1/*isCaseMap*/, "mapDpiDictSet"));
KINITv(share->convDpiDictSet, new_DictSet0(_ctx, 0, 1/*isCaseMap*/, "convDpiDictSet"));
KINITv(share->rconvDpiDictSet, new_DictSet0(_ctx, 0, 1/*isCaseMap*/, "convDpiDictSet"));
KINITv(share->enc, new_T(knh_getSystemEncoding()));
KINITv(share->in, new_InputStreamStdIn(_ctx, share->enc));
KINITv(share->out, new_OutputStreamStdOut(_ctx, share->enc));
KINITv(share->err, new_OutputStreamStdErr(_ctx, share->enc));
KINITv(share->props, new_DictMap0(_ctx, 20, 1/*isCaseMap*/, "System.props"));
KINITv(share->symbolDictCaseSet, new_DictSet0(_ctx, K_TFIELD_SIZE + 10, 1/*isCaseMap*/, "System.symbolDictSet"));
KINITv(share->symbolList, new_Array0(_ctx, K_TFIELD_SIZE + 10));
KINITv(share->urnDictSet, new_DictSet0(_ctx, 0, 0/*isCaseMap*/, "System.urnDictSet"));
KINITv(share->urns, new_Array0(_ctx, 1));
KINITv(share->corelang, new_(Lang));
knh_initSugarData(_ctx);
KINITv(share->tokenDictSet, new_DictSet0(_ctx, (TT_MAX - STT_MAX), 0/*isCaseMap*/, "System.tokenDictSet"));
// KINITv(share->URNAliasDictMap, new_DictMap0(_ctx, 0, 0/*isCaseMap*/, "System.URNAliasDictMap"));
KINITv(share->rootks, new_(KonohaSpace));
knh_loadScriptSystemData(_ctx, share->rootks, kapi);
knh_System_initPath(_ctx); // require rootks
KINITv(_ctx->script, new_(Script)); // require rootks
KINITv(_ctx->gma, new_(GammaBuilder)); // require script
knh_loadScriptSystemKonohaCode(_ctx); // require gamma
loadPolicy(_ctx); // added by Wakamori
knh_loadScriptSystemMethod(_ctx, kapi);
CommonContext_init(_ctx, ctx);
knh_loadScriptTermData(_ctx);
knh_loadScriptAliasTermData(_ctx);
share->ctx0 = ctx;
knh_GammaBuilder_init(_ctx); // initalize gamma->gf, reported by uh
knh_initBuiltInPackage(_ctx, knh_getLoaderAPI());
/* CompilerAPI */
KINITv(share->konoha_compiler, K_NULL);
share->compilerAPI = NULL;
share->contextCounter = 1;
share->threadCounter = 1;
share->stopCounter = 0;
share->gcStopCounter = 0;
KINITv(share->contextListNULL, new_Array0(_ctx, 4));
kArray_add(ctx->share->contextListNULL, knh_toContext(_ctx));
#if defined(K_USING_THREAD)
share->stop_cond = kthread_cond_init(_ctx);
share->start_cond = kthread_cond_init(_ctx);
share->close_cond = kthread_cond_init(_ctx);
#endif
return ctx;
}
kbool_t knh_VirtualMachine_launch(CTX ctx, ksfp_t *sfp)
{
#ifdef K_USING_SIGNAL
#if defined(K_USING_MINGW_)
knh_setsignal(ctx);
#else
struct sigaction sa_orig[32];
knh_bzero(sa_orig, sizeof(struct sigaction) * 32);
knh_setsignal(ctx, sa_orig, 32);
#endif /* defined(K_USING_MINGW_) */
kbool_t b = (knh_VirtualMachine_run(ctx, sfp, CODE_LAUNCH) == NULL);
if(ctx->signal != 0) {
#if defined(K_USING_MINGW_)
if(ctx->signal == SIGSEGV || ctx->signal == SIGILL) {
#else
if(ctx->signal == SIGSEGV || ctx->signal == SIGBUS || ctx->signal == SIGILL) {
#endif /* defined(K_USING_MINGW_) */
_Exit(EX_SOFTWARE);
}
}
#if defined(K_USING_MINGW_)
knh_unsetsignal(ctx);
#else
knh_unsetsignal(ctx, sa_orig, 32);
#endif /* defined(K_USING_MINGW_) */
return b;
#else
kbool_t b = (knh_VirtualMachine_run(ctx, sfp, CODE_LAUNCH) == NULL);
#endif
#if !defined(K_USING_MINGW_)
if(ctx->signal == SIGKILL) {
_Exit(EX_SOFTWARE);
}
#endif /* !defined(K_USING_MINGW_) */
return b;
}
/* ------------------------------------------------------------------------ */
#define OPT_EMPTY 0
#define OPT_NUMBER 1
#define OPT_STRING 2
#define OPT_(O) O, (sizeof(O)-1)
typedef struct {
const char *name;
size_t len;
int type;
void (*setopt)(int, const char *);
} knh_optdata_t ;
static knh_optdata_t optdata[] = {
{OPT_("-v"), OPT_NUMBER, opt_v},
{OPT_("-a"), OPT_NUMBER, opt_a},
{OPT_("-l"), OPT_STRING, opt_l},
{OPT_("--enforce-security"), OPT_STRING, opt_enforce_security},
{OPT_("--logcached"), OPT_STRING, opt_logcached},
{OPT_("--verbose:gc"), OPT_EMPTY, opt_verbose_gc},
{OPT_("--verbose:lang"), OPT_EMPTY, opt_verbose_lang},
{OPT_("--verbose:pref"), OPT_EMPTY, opt_verbose_pref},
{NULL, 0, OPT_EMPTY, NULL}, // END
};
static knh_optdata_t *knh_getoptdata(const char *name)
{
knh_optdata_t *d = optdata;
while(d->name != NULL) {
if(knh_strncmp(d->name, name, d->len) == 0) {
return d;
}
d++;
}
return NULL;
}
