Exemple #1
0
static knh_MailBox_t *knh_MailBox_new(CTX ctx)
{
	knh_MailBox_t *mailbox = (knh_MailBox_t *)KNH_MALLOC(ctx, sizeof(knh_MailBox_t));
	mailbox->end = 0;
	mailbox->msgs = (knh_Message_t **)KNH_MALLOC(ctx, sizeof(knh_Message_t *) * MAX_MAIL_NUM);
	int i = 0;
	for (i = 0; i < MAX_MAIL_NUM; i++) {
		mailbox->msgs[i] = (knh_Message_t *)KNH_MALLOC(ctx, sizeof(knh_Message_t));
	}
	return mailbox;
}
Exemple #2
0
static knh_Actor_t *knh_Actor_new(CTX ctx)
{
	knh_Actor_t *actor = (knh_Actor_t *)KNH_MALLOC(ctx, sizeof(knh_Actor_t));
	knh_ActorEX_t *b = (knh_ActorEX_t *)KNH_MALLOC(ctx, sizeof(knh_ActorEX_t));
	actor->mtd_info = (knh_MethodInfo_t **)KNH_MALLOC(ctx, sizeof(knh_MethodInfo_t *) * MAX_METHOD_NUM);
	int i = 0;
	for (i = 0; i < MAX_METHOD_NUM; i++) {
		actor->mtd_info[i] = (knh_MethodInfo_t *)KNH_MALLOC(ctx, sizeof(knh_MethodInfo_t));
	}
	actor->mailbox = knh_MailBox_new(ctx);
	actor->b = b;
	return actor;
}
Exemple #3
0
static void knh_actor_init(CTX ctx, knh_actor_t *a, const char *name, const char *host, int port)
{
	if (name != NULL) {
		size_t len = knh_strlen(name);
		a->name = (const char *)KNH_MALLOC(ctx, len);
		strncpy((char *)a->name, name, len);
	}
	if (host != NULL) {
		size_t len = knh_strlen(host);
		a->host = (const char *)KNH_MALLOC(ctx, len);
		strncpy((char *)a->host, host, len);
	}
	a->port = port;
}
KNHAPI(void) knh_ResultSet_initColumn(Ctx *ctx, knh_ResultSet_t *o, size_t column_size)
{
	size_t i;
	if(DP(o)->column_size != 0) {
		for(i = 0; i < DP(o)->column_size; i++) {
			KNH_FINALv(ctx, DP(o)->column[i].name);
		}
		KNH_FREE(ctx, DP(o)->column, sizeof(knh_dbschema_t) * DP(o)->column_size);
		DP(o)->column = NULL;
		if(DP(o)->qcur != NULL) {
			DP(o)->qcurfree(DP(o)->qcur);
			DP(o)->qcur = NULL;
		}
	}
	DP(o)->column_size = column_size;
	if(column_size > 0) {
		DP(o)->column = (knh_dbschema_t*)KNH_MALLOC(ctx, sizeof(knh_dbschema_t) * DP(o)->column_size);
		for(i = 0; i < DP(o)->column_size; i++) {
			DP(o)->column[i].type = CLASS_Object;
			KNH_INITv(DP(o)->column[i].name, TS_EMPTY);
			DP(o)->column[i].start = 0;
			DP(o)->column[i].len = 0;
		}
	}
	DP(o)->count = 0;
}
Exemple #5
0
const knh_dim_t *new_dim(CTX ctx, size_t capacity, size_t wsize)
{
	knh_dim_t *dim = (knh_dim_t*)KNH_MALLOC(ctx, sizeof(knh_dim_t));
	dim->capacity = capacity;
	dim->wsize = wsize;
	dim->dim = 1;
	dim->x = dim->xy = dim->xyz = capacity;
	return (const knh_dim_t*)dim;
}
Exemple #6
0
static knh_xblock_t *knh_generateWrapper(CTX ctx, void *callee, int argc, knh_ffiparam_t *argv)
{
  knh_xblock_t *blk = get_unused_xblock(ctx);
  knh_xblock_t *function = blk->block;

  size_t fidx = 0;
  int i = 0;
  knh_ffiparam_t *t;
  // local ffiarguments;
  ffi_cif *cif = (ffi_cif*)KNH_MALLOC(ctx, sizeof(ffi_cif));
  ffi_type **args = (ffi_type**)KNH_MALLOC(ctx, sizeof(ffi_type) * argc);
  void *values[1];
  
  for (i = 0; i < argc; i++) {
	t = &argv[i];
	if (t->sfpidx != -1) {
	  // it means arguments	
	  switch(t->type) {
	  case CLASS_Tvoid:
		// do nothing
		break;
	  case CLASS_Int:
		args[i] = &ffi_type_uint64;
		break;
	  case CLASS_Float:
		args[i] = &ffi_type_double;
		break;
	  default:
		args[i] = &ffi_type_pointer;
		break;
	  }
	}
  }

  if (ffi_prep_cif(cif, FFI_DEFAULT_ABI, argc,
				   &ffi_type_void, args) == FFI_OK) {
	fprintf(stderr, "OKAY!\n");
  } else {
	fprintf(stderr, "this is not okay!\n");
  }

}
Exemple #7
0
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;
}
Exemple #8
0
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;
}
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);
		}
	}
}
Exemple #10
0
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);
}
Exemple #11
0
void knh_Bytes_expands(CTX ctx, knh_Bytes_t *ba, size_t newsize)
{
	if(ba->dim->capacity == 0) {
		newsize = k_goodsize(newsize);
		ba->bu.ubuf = (knh_uchar_t*)KNH_MALLOC(ctx, newsize);
		ba->dim = new_dim(ctx, newsize, 1);
	}
	else {
		knh_uchar_t *ubuf = ba->bu.ubuf;
		ba->bu.ubuf = (knh_uchar_t*)KNH_REALLOC(ctx, ba->DBG_name, ba->bu.ubuf, ba->dim->capacity, newsize, 1);
		((knh_dim_t*)ba->dim)->capacity = newsize;
		if(unlikely(ctx->bufa == ba)) {
			KNH_INFO(ctx, "newsize=%ld, pointer=(%p => %p)", newsize, ubuf, ba->bu.ubuf);
			Bytes_checkstack(ctx, ubuf, ubuf + ba->bu.len, ba->bu.ubuf);
		}
	}
}
Exemple #12
0
/* ------------------------------------------------------------------------ */

/* Close an open blob */
//## @Native void GitBlob.close();
KMETHOD GitBlob_close(CTX ctx, ksfp_t *sfp _RIX)
{
    kGitBlob_free(ctx, sfp[0].p);
    RETURNvoid_();
}

/* Write an in-memory buffer to the ODB as a blob */
//## @Native @Static GitOid GitBlob.createFromBuffer(GitRepository repo, Bytes buffer);
KMETHOD GitBlob_createFromBuffer(CTX ctx, ksfp_t *sfp _RIX)
{
    git_oid *oid = (git_oid *)KNH_MALLOC(ctx, sizeof(git_oid));
    git_repository *repo = RawPtr_to(git_repository *, sfp[1]);
    const void *buffer = (const void *)BA_totext(sfp[2].ba);
    size_t len = BA_size(sfp[2].ba);
    int error = git_blob_create_frombuffer(oid, repo, buffer, len);
    if (error < GIT_SUCCESS) {
        TRACE_ERROR(ctx, "git_blob_create_frombuffer", error);
        KNH_FREE(ctx, oid, sizeof(git_oid));
        RETURN_(KNH_NULL);
    }
    RETURN_(new_ReturnRawPtr(ctx, sfp, oid));
}

/* Read a file from the working folder of a repository and write it to the
 * Object Database as a loose blob */
//## @Native @Static GitOid GitBlob.createFromFile(GitRepository repo, String path);
Exemple #13
0
static void WebserviceGlue_free(CTX ctx, void *ptr)
{
	if (ptr != NULL) {
	  ptr = NULL;
	}
}

/* ------------------------------------------------------------------------ */
/* [Webservice] */

#define WS_PATH_MAX (256)

//@Native Webservice Webservice.new(String path, Webservice _);
METHOD Webservice_new(CTX ctx, knh_sfp_t *sfp _RIX)
{
  knh_Webservice_t *proc = (knh_Webservice_t*)KNH_MALLOC(ctx, sizeof(knh_Webservice_t));
  char *pname = String_to(char *, sfp[1]);
  size_t path_size = knh_strlen(pname);
  if (pname != NULL && path_size < WS_PATH_MAX) {
	proc->path = KNH_MALLOC(ctx, path_size * sizeof(char));
	knh_memcpy(proc->path, pname, path_size+1);
	proc->path_size = path_size;
  }
  RETURN_(new_RawPtr(ctx, sfp[2].p, proc));
}

static METHOD Fmethod_wrapWebservice(CTX ctx, knh_sfp_t *sfp _RIX)
{
  knh_type_t rtype = knh_ParamArray_rtype(DP(sfp[K_MTDIDX].mtdNC)->mp);
  knh_Func_t *fo = sfp[0].fo;
  knh_WebserviceGlue_t *wglue = (knh_WebserviceGlue_t*)(((fo->mtd)->b)->cfunc);
Exemple #14
0
  po->path = NULL;
}

static void ProcessGlue_free(CTX ctx, void *ptr)
{
	if (ptr != NULL) {
	  ptr = NULL;
	}
}

/* ------------------------------------------------------------------------ */
//@Native Clib Clib.new(String libname, Clib _);
METHOD Clib_new(CTX ctx, knh_sfp_t *sfp _RIX)
{
  const char *libname = String_to(const char *, sfp[1]);
  knh_CLib_t *clib = (knh_CLib_t*)KNH_MALLOC(ctx, sizeof(knh_CLib_t));
  clib->handler = knh_dlopen(ctx, libname);
  knh_RawPtr_t *po = new_RawPtr(ctx, sfp[2].p, clib);
  RETURN_(po);
}

static METHOD Fmethod_wrapCLib(CTX ctx, knh_sfp_t *sfp _RIX)
{
  knh_type_t rtype = knh_ParamArray_rtype(DP(sfp[K_MTDIDX].mtdNC)->mp);
  knh_Func_t *fo = sfp[0].fo;
  knh_ClibGlue_t *cglue = (knh_ClibGlue_t*)(((fo->mtd)->b)->cfunc);
  //  fprintf(stderr, "fptr:%p, %p, %d, %p, %p\n", 
  //		  dg->fptr,
  //		  &(dg->cif), dg->argCount,
  //		  dg->retT, dg->argT);
  
Exemple #15
0
static knh_actor_t *knh_actor_malloc(CTX ctx)
{
	return (knh_actor_t *)KNH_MALLOC(ctx, sizeof(knh_actor_t));
}
Exemple #16
0
	if(po->rawptr != NULL) {
		knh_mutex_free(ctx, (kmutex_t *)po->rawptr);
		po->rawptr = NULL;
	}
}

/* ======================================================================== */
// [KMETHODS]

//## @Native Thread Thread.spawn(dynamic f, dynamic[] args)
KMETHOD Thread_spawn(CTX ctx, ksfp_t *sfp _RIX)
{
	kFunc *f = sfp[1].fo;
	kArray *args = sfp[2].a;
	if(IS_NOTNULL(((kObject *)f))) {
		Thread_t *t = (Thread_t *)KNH_MALLOC(ctx, sizeof(Thread_t));
		kcontext_t *newCtx = new_ThreadContext(WCTX(ctx));
		t->ctx = newCtx;
		t->func = f;
		t->args = args;
		kthread_create(ctx, &(t->thread), NULL, spawn_start, t);
		RETURN_(new_ReturnRawPtr(ctx, sfp, t));
	}
}

//## @Native void Thread.join();
KMETHOD Thread_join(CTX ctx, ksfp_t *sfp _RIX)
{
	Thread_t *t = RawPtr_to(Thread_t *, sfp[0]);
	void *v;