uv_buf_t jl_alloc_buf(uv_handle_t *handle, size_t suggested_size)
{
uv_buf_t buf;
JULIA_CB(alloc_buf,handle->data,1,CB_INT32,suggested_size);
if (!jl_is_tuple(ret) || !jl_is_pointer(jl_t0(ret)) || !jl_is_int32(jl_t1(ret))) {
jl_error("jl_alloc_buf: Julia function returned invalid value for buffer allocation callback");
}
buf.base = jl_unbox_voidpointer(jl_t0(ret));
buf.len = jl_unbox_int32(jl_t1(ret));
return buf;
}
DLLEXPORT void jl_uv_alloc_buf(uv_handle_t *handle, size_t suggested_size, uv_buf_t* buf)
{
if (handle->data) {
JULIA_CB(alloc_buf,handle->data,1,CB_INT32,suggested_size);
assert(jl_is_tuple(ret) && jl_is_pointer(jl_t0(ret)) && jl_is_int32(jl_t1(ret)));
buf->base = (char*)jl_unbox_voidpointer(jl_t0(ret));
buf->len = jl_unbox_int32(jl_t1(ret));
}
else {
buf->len = 0;
}
}
static void run_finalizers(void)
{
void *o = NULL;
jl_function_t *f=NULL;
jl_value_t *ff=NULL;
JL_GC_PUSH(&o, &f, &ff);
while (to_finalize.len > 0) {
o = arraylist_pop(&to_finalize);
ff = (jl_value_t*)ptrhash_get(&finalizer_table, o);
assert(ff != HT_NOTFOUND);
ptrhash_remove(&finalizer_table, o);
while (jl_is_tuple(ff)) {
f = (jl_function_t*)jl_t0(ff);
assert(jl_is_function(f));
JL_TRY {
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_CATCH {
}
ff = jl_t1(ff);
}
f = (jl_function_t*)ff;
assert(jl_is_function(f));
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_GC_POP();
}
static void run_finalizer(jl_value_t *o, jl_value_t *ff)
{
jl_function_t *f;
while (jl_is_tuple(ff)) {
f = (jl_function_t*)jl_t0(ff);
assert(jl_is_function(f));
JL_TRY {
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error in running finalizer: ");
jl_static_show(JL_STDERR, jl_exception_in_transit);
JL_PUTC('\n',JL_STDERR);
}
ff = jl_t1(ff);
}
f = (jl_function_t*)ff;
assert(jl_is_function(f));
JL_TRY {
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error in running finalizer: ");
jl_static_show(JL_STDERR, jl_exception_in_transit);
JL_PUTC('\n',JL_STDERR);
}
}
DLLEXPORT void jl_uv_alloc_buf(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
{
if (handle->data) {
jl_value_t *ret = JULIA_CB(alloc_buf,handle->data,1,CB_UINT,suggested_size);
assert(jl_is_tuple(ret) && jl_is_pointer(jl_t0(ret)));
buf->base = (char*)jl_unbox_voidpointer(jl_t0(ret));
#ifdef _P64
assert(jl_is_uint64(jl_t1(ret)));
buf->len = jl_unbox_uint64(jl_t1(ret));
#else
assert(jl_is_uint32(jl_t1(ret)));
buf->len = jl_unbox_uint32(jl_t1(ret));
#endif
}
else {
buf->len = 0;
}
}
static
jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tuple_t *type,
jl_function_t *method)
{
jl_methlist_t **pml = &mt->cache;
if (type->length > 0) {
jl_value_t *t0 = jl_t0(type);
uptrint_t uid=0;
// if t0 != jl_typetype_type and the argument is Type{...}, this
// method has specializations for singleton kinds and we use
// the table indexed for that purpose.
if (t0 != (jl_value_t*)jl_typetype_type && jl_is_type_type(t0)) {
jl_value_t *a0 = jl_tparam0(t0);
if (jl_is_struct_type(a0))
uid = ((jl_struct_type_t*)a0)->uid;
else if (jl_is_bits_type(a0))
uid = ((jl_bits_type_t*)a0)->uid;
if (uid > 0) {
if (mt->cache_targ == NULL)
mt->cache_targ = jl_alloc_cell_1d(0);
if (uid >= jl_array_len(mt->cache_targ)) {
jl_array_grow_end(mt->cache_targ, uid+4-jl_array_len(mt->cache_targ));
}
pml = (jl_methlist_t**)&jl_cellref(mt->cache_targ, uid);
goto ml_do_insert;
}
}
if (jl_is_struct_type(t0))
uid = ((jl_struct_type_t*)t0)->uid;
else if (jl_is_bits_type(t0))
uid = ((jl_bits_type_t*)t0)->uid;
if (uid > 0) {
if (mt->cache_arg1 == NULL)
mt->cache_arg1 = jl_alloc_cell_1d(0);
if (uid >= jl_array_len(mt->cache_arg1)) {
jl_array_grow_end(mt->cache_arg1, uid+4-jl_array_len(mt->cache_arg1));
}
pml = (jl_methlist_t**)&jl_cellref(mt->cache_arg1, uid);
}
}
ml_do_insert:
return jl_method_list_insert(pml, type, method, jl_null, 0)->func;
}
DLLEXPORT void *jl_eval_string(char *str)
{
#ifdef COPY_STACKS
jl_root_task->stackbase = (char*)&str;
if (jl_setjmp(jl_root_task->base_ctx, 1)) {
jl_switch_stack(jl_current_task, jl_jmp_target);
}
#endif
jl_value_t *r;
JL_TRY {
jl_value_t *ast = jl_parse_string(str, 0, 1);
JL_GC_PUSH(&ast);
r = jl_toplevel_eval(jl_t0(ast));
JL_GC_POP();
}
JL_CATCH {
//jl_show(jl_stderr_obj(), jl_exception_in_transit);
r = jl_exception_in_transit;
}
return r;
}
/*
Method caches are divided into three parts: one for signatures where
the first argument is a singleton kind (Type{Foo}), one indexed by the
UID of the first argument's type in normal cases, and a fallback
table of everything else.
*/
static jl_function_t *jl_method_table_assoc_exact_by_type(jl_methtable_t *mt,
jl_tuple_t *types)
{
jl_methlist_t *ml = NULL;
if (types->length > 0) {
jl_value_t *ty = jl_t0(types);
uptrint_t uid;
if (jl_is_type_type(ty)) {
jl_value_t *a0 = jl_tparam0(ty);
jl_value_t *tty = (jl_value_t*)jl_typeof(a0);
if ((tty == (jl_value_t*)jl_struct_kind && (uid = ((jl_struct_type_t*)a0)->uid)) ||
(tty == (jl_value_t*)jl_bits_kind && (uid = ((jl_bits_type_t*)a0)->uid))) {
if (mt->cache_targ &&
uid < jl_array_len(mt->cache_targ)) {
ml = (jl_methlist_t*)jl_cellref(mt->cache_targ, uid);
if (ml)
goto mt_assoc_bt_lkup;
}
}
}
if ((jl_is_struct_type(ty) && (uid = ((jl_struct_type_t*)ty)->uid)) ||
(jl_is_bits_type(ty) && (uid = ((jl_bits_type_t*)ty)->uid))) {
if (mt->cache_arg1 && uid < jl_array_len(mt->cache_arg1)) {
ml = (jl_methlist_t*)jl_cellref(mt->cache_arg1, uid);
}
}
}
if (ml == NULL)
ml = mt->cache;
mt_assoc_bt_lkup:
while (ml != NULL) {
if (cache_match_by_type(&jl_tupleref(types,0), types->length,
(jl_tuple_t*)ml->sig, ml->va==jl_true)) {
return ml->func;
}
ml = ml->next;
}
return NULL;
}
DLLEXPORT jl_value_t *jl_method_def(jl_sym_t *name, jl_value_t **bp, jl_binding_t *bnd,
jl_tuple_t *argtypes, jl_function_t *f, jl_value_t *isstaged,
jl_value_t *call_func, int iskw)
{
// argtypes is a tuple ((types...), (typevars...))
jl_tuple_t *t = (jl_tuple_t*)jl_t1(argtypes);
argtypes = (jl_tuple_t*)jl_t0(argtypes);
jl_value_t *gf=NULL;
JL_GC_PUSH3(&gf, &argtypes, &t);
if (bnd && bnd->value != NULL && !bnd->constp) {
jl_errorf("cannot define function %s; it already has a value",
bnd->name->name);
}
if (*bp != NULL) {
gf = *bp;
if (!jl_is_gf(gf)) {
if (jl_is_datatype(gf)) {
// DataType: define `call`, for backwards compat with outer constructors
if (call_func == NULL)
call_func = (jl_value_t*)jl_module_call_func(jl_current_module);
size_t na = jl_tuple_len(argtypes);
jl_tuple_t *newargtypes = jl_alloc_tuple(1 + na);
JL_GC_PUSH1(&newargtypes);
size_t i=0;
if (iskw) {
assert(na > 0);
// for kw sorter, keep container argument first
jl_tupleset(newargtypes, 0, jl_tupleref(argtypes, 0));
i++;
}
jl_tupleset(newargtypes, i, jl_wrap_Type(gf));
i++;
for(; i < na+1; i++) {
jl_tupleset(newargtypes, i, jl_tupleref(argtypes, i-1));
}
argtypes = newargtypes;
JL_GC_POP();
gf = call_func;
name = call_sym;
// edit args, insert type first
if (!jl_is_expr(f->linfo->ast))
f->linfo->ast = jl_uncompress_ast(f->linfo, f->linfo->ast);
jl_array_t *al = jl_lam_args((jl_expr_t*)f->linfo->ast);
if (jl_array_len(al) == 0) {
al = jl_alloc_cell_1d(1);
jl_exprarg(f->linfo->ast, 0) = (jl_value_t*)al;
}
else {
jl_array_grow_beg(al, 1);
}
if (iskw) {
jl_cellset(al, 0, jl_cellref(al, 1));
jl_cellset(al, 1, (jl_value_t*)jl_gensym());
}
else {
jl_cellset(al, 0, (jl_value_t*)jl_gensym());
}
}
if (!jl_is_gf(gf)) {
jl_error("invalid method definition: not a generic function");
}
}
if (iskw) {
bp = (jl_value_t**)&((jl_methtable_t*)((jl_function_t*)gf)->env)->kwsorter;
gf = *bp;
}
}
size_t na = jl_tuple_len(argtypes);
for(size_t i=0; i < na; i++) {
jl_value_t *elt = jl_tupleref(argtypes,i);
if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
jl_lambda_info_t *li = f->linfo;
jl_errorf("invalid type for argument %s in method definition for %s at %s:%d",
jl_lam_argname(li,i)->name, name->name, li->file->name, li->line);
}
}
int ishidden = !!strchr(name->name, '#');
for(size_t i=0; i < jl_tuple_len(t); i++) {
jl_value_t *tv = jl_tupleref(t,i);
if (!jl_is_typevar(tv))
jl_type_error_rt(name->name, "method definition", (jl_value_t*)jl_tvar_type, tv);
if (!ishidden && !type_contains((jl_value_t*)argtypes, tv)) {
JL_PRINTF(JL_STDERR, "Warning: static parameter %s does not occur in signature for %s",
((jl_tvar_t*)tv)->name->name, name->name);
print_func_loc(JL_STDERR, f->linfo);
JL_PRINTF(JL_STDERR, ".\nThe method will not be callable.\n");
}
}
if (bnd) {
bnd->constp = 1;
}
if (*bp == NULL) {
gf = (jl_value_t*)jl_new_generic_function(name);
*bp = gf;
}
assert(jl_is_function(f));
assert(jl_is_tuple(argtypes));
assert(jl_is_tuple(t));
jl_add_method((jl_function_t*)gf, argtypes, f, t, isstaged == jl_true);
if (jl_boot_file_loaded &&
f->linfo && f->linfo->ast && jl_is_expr(f->linfo->ast)) {
jl_lambda_info_t *li = f->linfo;
li->ast = jl_compress_ast(li, li->ast);
}
JL_GC_POP();
return gf;
}
DLLEXPORT jl_value_t *jl_method_def(jl_sym_t *name, jl_value_t **bp, jl_binding_t *bnd,
jl_tuple_t *argtypes, jl_function_t *f)
{
// argtypes is a tuple ((types...), (typevars...))
jl_tuple_t *t = (jl_tuple_t*)jl_t1(argtypes);
argtypes = (jl_tuple_t*)jl_t0(argtypes);
jl_value_t *gf=NULL;
if (bnd && bnd->value != NULL && !bnd->constp) {
jl_errorf("cannot define function %s; it already has a value",
bnd->name->name);
}
if (*bp != NULL) {
gf = *bp;
if (!jl_is_gf(gf)) {
if (jl_is_datatype(gf) &&
((jl_function_t*)gf)->fptr == jl_f_ctor_trampoline) {
jl_add_constructors((jl_datatype_t*)gf);
}
if (!jl_is_gf(gf)) {
jl_error("invalid method definition: not a generic function");
}
}
}
size_t na = jl_tuple_len(argtypes);
for(size_t i=0; i < na; i++) {
jl_value_t *elt = jl_tupleref(argtypes,i);
if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
jl_lambda_info_t *li = f->linfo;
jl_errorf("invalid type for argument %s in method definition for %s at %s:%d",
jl_lam_argname(li,i)->name, name->name, li->file->name, li->line);
}
}
int ishidden = !!strchr(name->name, '#');
for(size_t i=0; i < jl_tuple_len(t); i++) {
jl_value_t *tv = jl_tupleref(t,i);
if (!jl_is_typevar(tv))
jl_type_error_rt(name->name, "method definition", (jl_value_t*)jl_tvar_type, tv);
if (!ishidden && !type_contains((jl_value_t*)argtypes, tv)) {
JL_PRINTF(JL_STDERR, "Warning: static parameter %s does not occur in signature for %s",
((jl_tvar_t*)tv)->name->name, name->name);
print_func_loc(JL_STDERR, f->linfo);
JL_PRINTF(JL_STDERR, ".\nThe method will not be callable.\n");
}
}
if (bnd) {
bnd->constp = 1;
}
if (*bp == NULL) {
gf = (jl_value_t*)jl_new_generic_function(name);
*bp = gf;
}
JL_GC_PUSH1(&gf);
assert(jl_is_function(f));
assert(jl_is_tuple(argtypes));
assert(jl_is_tuple(t));
jl_add_method((jl_function_t*)gf, argtypes, f, t);
if (jl_boot_file_loaded &&
f->linfo && f->linfo->ast && jl_is_expr(f->linfo->ast)) {
jl_lambda_info_t *li = f->linfo;
li->ast = jl_compress_ast(li, li->ast);
}
JL_GC_POP();
return gf;
}