static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
{
if (jl_is_symbol(v))
return symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v));
if (v == jl_true)
return jl_ast_ctx(fl_ctx)->true_sym;
if (v == jl_false)
return jl_ast_ctx(fl_ctx)->false_sym;
if (v == jl_nothing)
return fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->null_sym, fl_ctx->NIL);
if (jl_is_expr(v)) {
jl_expr_t *ex = (jl_expr_t*)v;
value_t args = fl_ctx->NIL;
fl_gc_handle(fl_ctx, &args);
array_to_list(fl_ctx, ex->args, &args);
value_t hd = julia_to_scm_(fl_ctx, (jl_value_t*)ex->head);
if (ex->head == lambda_sym && jl_expr_nargs(ex)>0 && jl_is_array(jl_exprarg(ex,0))) {
value_t llist = fl_ctx->NIL;
fl_gc_handle(fl_ctx, &llist);
array_to_list(fl_ctx, (jl_array_t*)jl_exprarg(ex,0), &llist);
car_(args) = llist;
fl_free_gc_handles(fl_ctx, 1);
}
value_t scmv = fl_cons(fl_ctx, hd, args);
fl_free_gc_handles(fl_ctx, 1);
return scmv;
}
// GC Note: jl_fieldref(v, 0) allocate for LabelNode, GotoNode
// but we don't need a GC root here because julia_to_list2
// shouldn't allocate in this case.
if (jl_typeis(v, jl_labelnode_type))
return julia_to_list2(fl_ctx, (jl_value_t*)label_sym, jl_fieldref(v,0));
if (jl_typeis(v, jl_linenumbernode_type))
return julia_to_list2(fl_ctx, (jl_value_t*)line_sym, jl_fieldref(v,0));
if (jl_typeis(v, jl_gotonode_type))
return julia_to_list2(fl_ctx, (jl_value_t*)goto_sym, jl_fieldref(v,0));
if (jl_typeis(v, jl_quotenode_type))
return julia_to_list2(fl_ctx, (jl_value_t*)inert_sym, jl_fieldref(v,0));
if (jl_typeis(v, jl_newvarnode_type))
return julia_to_list2(fl_ctx, (jl_value_t*)newvar_sym, jl_fieldref(v,0));
if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v)))
return fixnum(jl_unbox_long(v));
if (jl_is_ssavalue(v))
jl_error("SSAValue objects should not occur in an AST");
if (jl_is_slot(v))
jl_error("Slot objects should not occur in an AST");
value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
*(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = v;
return opaque;
}
DLLEXPORT void jl_show_any(jl_value_t *v)
{
// fallback for printing some other builtin types
ios_t *s = jl_current_output_stream();
if (jl_is_tuple(v)) {
show_tuple((jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(v);
}
else if (jl_is_func(v)) {
show_function(v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
ios_printf(s, "#<intrinsic-function %d>", *(uint32_t*)jl_bits_data(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
if (jl_is_struct_type(t)) {
jl_struct_type_t *st = (jl_struct_type_t*)t;
ios_puts(st->name->name->name, s);
ios_putc('(', s);
size_t i;
size_t n = st->names->length;
for(i=0; i < n; i++) {
jl_show(nth_field(v, i));
if (i < n-1)
ios_putc(',', s);
}
ios_putc(')', s);
}
}
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
ios_t *s = (ios_t*)jl_iostr_data(str);
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "#<intrinsic-function %d>", *(uint32_t*)jl_bits_data(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
if (jl_is_struct_type(t)) {
jl_struct_type_t *st = (jl_struct_type_t*)t;
JL_PUTS(st->name->name->name, s);
JL_PUTC('(', s);
size_t i;
size_t n = jl_tuple_len(st->names);
for(i=0; i < n; i++) {
jl_show(str, nth_field(v, i));
if (i < n-1)
JL_PUTC(',', s);
}
JL_PUTC(')', s);
}
}
}
// get the next runnable task from the multiq
static jl_task_t *get_next_task(jl_value_t *getsticky)
{
jl_task_t *task = (jl_task_t*)jl_apply(&getsticky, 1);
if (jl_typeis(task, jl_task_type))
return task;
return multiq_deletemin();
}
// get binding for assignment
jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var)
{
jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
jl_binding_t *b;
if (*bp == HT_NOTFOUND) {
b = (jl_binding_t*)allocb(sizeof(jl_binding_t));
b->name = var;
b->value = NULL;
b->type = (jl_type_t*)jl_any_type;
b->constp = 0;
b->exportp = 0;
*bp = b;
// keep track of all variables added after the VARIABLES array
// is defined
if (jl_system_module) {
if (varlist_binding == NULL) {
varlist_binding = jl_get_binding(jl_system_module, jl_symbol("VARIABLES"));
}
if (varlist_binding && varlist_binding->value != NULL &&
jl_typeis(varlist_binding->value, jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)varlist_binding->value;
jl_cell_1d_push(a, (jl_value_t*)var);
}
}
}
return *bp;
}
DLLEXPORT void jl_cell_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
{
assert(jl_typeis(a, jl_array_any_type));
jl_array_grow_end(a, 2);
jl_cellset(a, jl_array_dim(a,0)-2, b);
jl_cellset(a, jl_array_dim(a,0)-1, c);
}
JL_DLLEXPORT void jl_array_ptr_1d_push(jl_array_t *a, jl_value_t *item)
{
assert(jl_typeis(a, jl_array_any_type));
jl_array_grow_end(a, 1);
size_t n = jl_array_nrows(a);
jl_array_ptr_set(a, n - 1, item);
}
JL_DLLEXPORT void jl_array_ptr_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
{
assert(jl_typeis(a, jl_array_any_type));
jl_array_grow_end(a, 2);
size_t n = jl_array_nrows(a);
jl_array_ptr_set(a, n - 2, b);
jl_array_ptr_set(a, n - 1, c);
}
static jl_value_t *copy_ast(jl_value_t *expr, jl_tuple_t *sp, int do_sp)
{
if (jl_is_symbol(expr)) {
if (!do_sp) return expr;
// pre-evaluate certain static parameters to help type inference
for(int i=0; i < jl_tuple_len(sp); i+=2) {
assert(jl_is_typevar(jl_tupleref(sp,i)));
if ((jl_sym_t*)expr == ((jl_tvar_t*)jl_tupleref(sp,i))->name) {
jl_value_t *spval = jl_tupleref(sp,i+1);
if (jl_is_long(spval))
return spval;
}
}
}
else if (jl_is_lambda_info(expr)) {
jl_lambda_info_t *li = (jl_lambda_info_t*)expr;
/*
if (sp == jl_null && li->ast &&
jl_lam_capt((jl_expr_t*)li->ast)->length == 0)
return expr;
*/
// TODO: avoid if above condition is true and decls have already
// been evaluated.
JL_GC_PUSH(&li);
li = jl_add_static_parameters(li, sp);
li->ast = jl_prepare_ast(li, li->sparams);
JL_GC_POP();
return (jl_value_t*)li;
}
else if (jl_typeis(expr,jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)expr;
jl_array_t *na = jl_alloc_cell_1d(jl_array_len(a));
JL_GC_PUSH(&na);
size_t i;
for(i=0; i < jl_array_len(a); i++)
jl_cellset(na, i, copy_ast(jl_cellref(a,i), sp, do_sp));
JL_GC_POP();
return (jl_value_t*)na;
}
else if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
jl_expr_t *ne = jl_exprn(e->head, jl_array_len(e->args));
JL_GC_PUSH(&ne);
size_t i;
if (e->head == lambda_sym) {
jl_exprarg(ne, 0) = copy_ast(jl_exprarg(e,0), sp, 0);
jl_exprarg(ne, 1) = copy_ast(jl_exprarg(e,1), sp, 0);
jl_exprarg(ne, 2) = copy_ast(jl_exprarg(e,2), sp, 1);
}
else {
for(i=0; i < jl_array_len(e->args); i++)
jl_exprarg(ne, i) = copy_ast(jl_exprarg(e,i), sp, 1);
}
JL_GC_POP();
return (jl_value_t*)ne;
}
return expr;
}
static value_t julia_to_scm(jl_value_t *v)
{
if (jl_is_symbol(v)) {
return symbol(((jl_sym_t*)v)->name);
}
if (v == jl_true) {
return FL_T;
}
if (v == jl_false) {
return FL_F;
}
if (v == jl_nothing) {
return fl_cons(symbol("null"), FL_NIL);
}
if (jl_is_expr(v)) {
jl_expr_t *ex = (jl_expr_t*)v;
value_t args = array_to_list(ex->args);
fl_gc_handle(&args);
value_t hd = julia_to_scm((jl_value_t*)ex->head);
value_t scmv = fl_cons(hd, args);
fl_free_gc_handles(1);
return scmv;
}
if (jl_typeis(v, jl_linenumbernode_type)) {
return julia_to_list2((jl_value_t*)line_sym, jl_fieldref(v,0));
}
if (jl_typeis(v, jl_labelnode_type)) {
return julia_to_list2((jl_value_t*)label_sym, jl_fieldref(v,0));
}
if (jl_typeis(v, jl_gotonode_type)) {
return julia_to_list2((jl_value_t*)goto_sym, jl_fieldref(v,0));
}
if (jl_typeis(v, jl_quotenode_type)) {
return julia_to_list2((jl_value_t*)quote_sym, jl_fieldref(v,0));
}
if (jl_typeis(v, jl_topnode_type)) {
return julia_to_list2((jl_value_t*)top_sym, jl_fieldref(v,0));
}
if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v))) {
return fixnum(jl_unbox_long(v));
}
value_t opaque = cvalue(jvtype, sizeof(void*));
*(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = v;
return opaque;
}
static int is_ast_node(jl_value_t *v)
{
return jl_is_symbol(v) || jl_is_expr(v) ||
jl_typeis(v, jl_array_any_type) || jl_is_tuple(v) ||
jl_is_union_type(v) || jl_is_int32(v) || jl_is_int64(v) ||
jl_is_symbolnode(v) || jl_is_bool(v) || jl_is_typevar(v) ||
jl_is_topnode(v) || jl_is_quotenode(v) || jl_is_gotonode(v) ||
jl_is_labelnode(v) || jl_is_linenode(v);
}
JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a)
{
jl_ptls_t ptls = jl_get_ptls_states();
if (!jl_typeis(a, jl_array_uint8_type))
jl_type_error("jl_array_to_string", (jl_value_t*)jl_array_uint8_type, (jl_value_t*)a);
jl_value_t *s = jl_gc_alloc(ptls, sizeof(void*), jl_string_type);
jl_set_nth_field(s, 0, (jl_value_t*)a);
return s;
}
jl_value_t *jl_array_to_string(jl_array_t *a)
{
if (!jl_typeis(a, jl_array_uint8_type))
jl_type_error("jl_array_to_string", (jl_value_t*)jl_array_uint8_type, (jl_value_t*)a);
jl_datatype_t *string_type = u8_isvalid((char*)a->data, jl_array_len(a)) == 1 ? // ASCII
jl_ascii_string_type : jl_utf8_string_type;
jl_value_t *s = (jl_value_t*)jl_gc_alloc_1w();
jl_set_typeof(s, string_type);
jl_set_nth_field(s, 0, (jl_value_t*)a);
return s;
}
static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule, jl_module_t **ctx)
{
jl_ptls_t ptls = jl_get_ptls_states();
JL_TIMING(MACRO_INVOCATION);
size_t nargs = jl_array_len(args) + 1;
JL_NARGSV("macrocall", 3); // macro name, location, and module
jl_value_t **margs;
JL_GC_PUSHARGS(margs, nargs);
int i;
margs[0] = jl_array_ptr_ref(args, 0);
// __source__ argument
jl_value_t *lno = jl_array_ptr_ref(args, 1);
margs[1] = lno;
if (!jl_typeis(lno, jl_linenumbernode_type)) {
margs[1] = jl_new_struct(jl_linenumbernode_type, jl_box_long(0), jl_nothing);
}
margs[2] = (jl_value_t*)inmodule;
for (i = 3; i < nargs; i++)
margs[i] = jl_array_ptr_ref(args, i - 1);
size_t last_age = ptls->world_age;
size_t world = jl_world_counter;
ptls->world_age = world;
jl_value_t *result;
JL_TRY {
margs[0] = jl_toplevel_eval(*ctx, margs[0]);
jl_method_instance_t *mfunc = jl_method_lookup(jl_gf_mtable(margs[0]), margs, nargs, 1, world);
if (mfunc == NULL) {
jl_method_error((jl_function_t*)margs[0], margs, nargs, world);
// unreachable
}
*ctx = mfunc->def.method->module;
result = mfunc->invoke(mfunc, margs, nargs);
}
JL_CATCH {
if (jl_loaderror_type == NULL) {
jl_rethrow();
}
else {
jl_value_t *lno = margs[1];
jl_value_t *file = jl_fieldref(lno, 1);
if (jl_is_symbol(file))
margs[0] = jl_cstr_to_string(jl_symbol_name((jl_sym_t*)file));
else
margs[0] = jl_cstr_to_string("<macrocall>");
margs[1] = jl_fieldref(lno, 0); // extract and allocate line number
jl_rethrow_other(jl_new_struct(jl_loaderror_type, margs[0], margs[1],
ptls->exception_in_transit));
}
}
ptls->world_age = last_age;
JL_GC_POP();
return result;
}
int jl_code_requires_compiler(jl_code_info_t *src)
{
jl_array_t *body = src->code;
assert(jl_typeis(body, jl_array_any_type));
size_t i;
int has_intrinsics = 0, has_defs = 0;
for(i=0; i < jl_array_len(body); i++) {
jl_value_t *stmt = jl_array_ptr_ref(body,i);
expr_attributes(stmt, &has_intrinsics, &has_defs);
if (has_intrinsics)
return 1;
}
return 0;
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
ios_t *s = (ios_t*)jl_iostr_data(str);
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "#<intrinsic-function %d>", *(uint32_t*)jl_bits_data(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
assert(jl_is_struct_type(t) || jl_is_bits_type(t));
jl_tag_type_t *tt = (jl_tag_type_t*)t;
JL_PUTS(tt->name->name->name, s);
if (tt->parameters != jl_null) {
jl_show_tuple(str, tt->parameters, '{', '}', 0);
}
JL_PUTC('(', s);
if (jl_is_struct_type(tt)) {
jl_struct_type_t *st = (jl_struct_type_t*)tt;
size_t i;
size_t n = jl_tuple_len(st->names);
for(i=0; i < n; i++) {
jl_value_t *fval = jl_get_nth_field(v, i);
if (fval == NULL)
JL_PUTS("#undef", s);
else
jl_show(str, fval);
if (i < n-1)
JL_PUTC(',', s);
}
}
else {
size_t nb = jl_bitstype_nbits(tt)/8;
char *data = (char*)jl_bits_data(v);
JL_PUTS("0x", s);
for(int i=nb-1; i >= 0; --i)
ios_printf(s, "%02hhx", data[i]);
}
JL_PUTC(')', s);
}
}
static int is_ast_node(jl_value_t *v)
{
if (jl_is_lambda_info(v)) {
jl_lambda_info_t *li = (jl_lambda_info_t*)v;
if (jl_is_expr(li->ast))
li->ast = jl_compress_ast(li, li->ast);
return 0;
}
return jl_is_symbol(v) || jl_is_expr(v) ||
jl_typeis(v, jl_array_any_type) || jl_is_tuple(v) ||
jl_is_union_type(v) || jl_is_int32(v) || jl_is_int64(v) ||
jl_is_symbolnode(v) || jl_is_bool(v) || jl_is_typevar(v) ||
jl_is_topnode(v) || jl_is_quotenode(v) || jl_is_gotonode(v) ||
jl_is_labelnode(v) || jl_is_linenode(v) || jl_is_getfieldnode(v);
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
uv_stream_t *s = ((uv_stream_t**)str)[1];
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "# intrinsic function %d", *(uint32_t*)jl_data_ptr(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
assert(jl_is_datatype(t));
jl_datatype_t *dt = (jl_datatype_t*)t;
show_type(str, t);
JL_PUTC('(', s);
if (jl_tuple_len(dt->names)>0 || dt->size==0) {
size_t i;
size_t n = jl_tuple_len(dt->names);
for(i=0; i < n; i++) {
jl_value_t *fval = jl_get_nth_field(v, i);
if (fval == NULL)
JL_PUTS("#undef", s);
else
jl_show(str, fval);
if (i < n-1)
JL_PUTC(',', s);
}
}
else {
size_t nb = jl_datatype_size(dt);
char *data = (char*)jl_data_ptr(v);
JL_PUTS("0x", s);
for(int i=nb-1; i >= 0; --i)
jl_printf(s, "%02hhx", data[i]);
}
JL_PUTC(')', s);
}
}
int jl_has_intrinsics(jl_expr_t *ast, jl_expr_t *e, jl_module_t *m)
{
if (jl_array_len(e->args) == 0)
return 0;
if (e->head == static_typeof_sym) return 1;
jl_value_t *e0 = jl_exprarg(e,0);
if (e->head == call_sym) {
jl_value_t *sv = jl_static_eval(e0, NULL, m, (jl_value_t*)jl_emptysvec, ast, 0, 0);
if (sv && jl_typeis(sv, jl_intrinsic_type))
return 1;
}
int i;
for(i=0; i < jl_array_len(e->args); i++) {
jl_value_t *a = jl_exprarg(e,i);
if (jl_is_expr(a) && jl_has_intrinsics(ast, (jl_expr_t*)a, m))
return 1;
}
return 0;
}
DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
{
if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
size_t i, l = jl_array_len(e->args);
jl_expr_t *ne = NULL;
JL_GC_PUSH2(&ne, &expr);
ne = jl_exprn(e->head, l);
if (l == 0) {
ne->args = jl_alloc_cell_1d(0);
}
else {
for(i=0; i < l; i++)
jl_exprarg(ne, i) = jl_copy_ast(jl_exprarg(e,i));
}
JL_GC_POP();
return (jl_value_t*)ne;
}
else if (jl_typeis(expr,jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)expr;
size_t i, l = jl_array_len(a);
jl_array_t *na = NULL;
JL_GC_PUSH2(&na, &expr);
na = jl_alloc_cell_1d(l);
for(i=0; i < l; i++)
jl_cellset(na, i, jl_copy_ast(jl_cellref(a,i)));
JL_GC_POP();
return (jl_value_t*)na;
}
else if (jl_is_quotenode(expr)) {
if (jl_is_symbol(jl_fieldref(expr,0)))
return expr;
jl_value_t *q = NULL;
JL_GC_PUSH2(&q, &expr);
q = jl_copy_ast(jl_fieldref(expr,0));
jl_value_t *v = jl_new_struct(jl_quotenode_type, q);
JL_GC_POP();
return v;
}
return expr;
}
JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
{
if (expr == NULL) {
return NULL;
}
else if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
size_t i, l = jl_array_len(e->args);
jl_expr_t *ne = NULL;
JL_GC_PUSH2(&ne, &expr);
ne = jl_exprn(e->head, l);
if (l == 0) {
ne->args = jl_alloc_vec_any(0);
jl_gc_wb(ne, ne->args);
}
else {
for(i=0; i < l; i++) {
jl_exprargset(ne, i, jl_copy_ast(jl_exprarg(e,i)));
}
}
JL_GC_POP();
return (jl_value_t*)ne;
}
else if (jl_typeis(expr,jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)expr;
size_t i, l = jl_array_len(a);
jl_array_t *na = NULL;
JL_GC_PUSH2(&na, &expr);
na = jl_alloc_vec_any(l);
for(i=0; i < l; i++)
jl_array_ptr_set(na, i, jl_copy_ast(jl_array_ptr_ref(a,i)));
JL_GC_POP();
return (jl_value_t*)na;
}
return expr;
}
jl_binding_t *jl_get_binding(jl_module_t *m, jl_sym_t *var)
{
jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
if (*bp == HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)allocb(sizeof(jl_binding_t));
b->name = var;
b->value = NULL;
b->type = (jl_type_t*)jl_any_type;
b->constp = 0;
b->exportp = 0;
*bp = b;
// keep track of all variables added after the VARIABLES array
// is defined
if (varlist_binding &&
varlist_binding->value != NULL &&
jl_typeis(varlist_binding->value, jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)varlist_binding->value;
jl_array_grow_end(a, 1);
jl_cellset(a, a->length-1, (jl_value_t*)var);
}
}
return *bp;
}
DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v)
{
// mimic jl_show, but never calling a julia method
size_t n = 0;
if (v == NULL) {
n += JL_PRINTF(out, "<null>");
}
else if (jl_is_lambda_info(v)) {
jl_lambda_info_t *li = (jl_lambda_info_t*)v;
n += jl_static_show(out, (jl_value_t*)li->module);
n += JL_PRINTF(out, ".%s", li->name->name);
if (li->specTypes) {
n += jl_static_show(out, (jl_value_t*)li->specTypes);
}
else {
n += JL_PRINTF(out, "(?)");
}
}
else if (jl_is_tuple(v)) {
n += jl_show_tuple(out, (jl_tuple_t*)v, "(", ")", 1);
}
else if (jl_is_vararg_type(v)) {
n += jl_static_show(out, jl_tparam0(v));
n += JL_PRINTF(out, "...");
}
else if (jl_is_datatype(v)) {
jl_datatype_t *dv = (jl_datatype_t*)v;
if (dv->name->module != jl_core_module) {
n += jl_static_show(out, (jl_value_t*)dv->name->module);
JL_PUTS(".", out); n += 1;
}
n += JL_PRINTF(out, "%s", dv->name->name->name);
if (dv->parameters) {
size_t j, tlen = jl_tuple_len(dv->parameters);
if (tlen > 0) {
n += JL_PRINTF(out, "{");
for (j = 0; j < tlen; j++) {
jl_value_t *p = jl_tupleref(dv->parameters,j);
n += jl_static_show(out, p);
if (j != tlen-1)
n += JL_PRINTF(out, ", ");
}
n += JL_PRINTF(out, "}");
}
}
}
else if (jl_is_func(v)) {
if (jl_is_gf(v)) {
n += JL_PRINTF(out, "%s", jl_gf_name(v)->name);
}
else {
n += JL_PRINTF(out, "<# function>");
}
}
else if (jl_typeis(v, jl_intrinsic_type)) {
n += JL_PRINTF(out, "<# intrinsic function %d>", *(uint32_t*)jl_data_ptr(v));
}
else if (jl_is_int64(v)) {
n += JL_PRINTF(out, "%d", jl_unbox_int64(v));
}
else if (jl_is_int32(v)) {
n += JL_PRINTF(out, "%d", jl_unbox_int32(v));
}
else if (jl_typeis(v,jl_int16_type)) {
n += JL_PRINTF(out, "%d", jl_unbox_int16(v));
}
else if (jl_typeis(v,jl_int8_type)) {
n += JL_PRINTF(out, "%d", jl_unbox_int8(v));
}
else if (jl_is_uint64(v)) {
n += JL_PRINTF(out, "0x%016x", jl_unbox_uint64(v));
}
else if (jl_is_uint32(v)) {
n += JL_PRINTF(out, "0x%08x", jl_unbox_uint32(v));
}
else if (jl_typeis(v,jl_uint16_type)) {
n += JL_PRINTF(out, "0x%04x", jl_unbox_uint16(v));
}
else if (jl_typeis(v,jl_uint8_type)) {
n += JL_PRINTF(out, "0x%02x", jl_unbox_uint8(v));
}
else if (jl_is_cpointer(v)) {
#ifdef _P64
n += JL_PRINTF(out, "0x%016x", jl_unbox_voidpointer(v));
#else
n += JL_PRINTF(out, "0x%08x", jl_unbox_voidpointer(v));
#endif
}
else if (jl_is_float32(v)) {
n += JL_PRINTF(out, "%g", jl_unbox_float32(v));
}
else if (jl_is_float64(v)) {
n += JL_PRINTF(out, "%g", jl_unbox_float64(v));
}
else if (v == jl_true) {
n += JL_PRINTF(out, "true");
}
else if (v == jl_false) {
n += JL_PRINTF(out, "false");
}
else if (jl_is_byte_string(v)) {
n += JL_PRINTF(out, "\"%s\"", jl_iostr_data(v));
}
else if (v == jl_bottom_type) {
n += JL_PRINTF(out, "Void");
}
else if (jl_is_uniontype(v)) {
n += JL_PRINTF(out, "Union");
n += jl_static_show(out, (jl_value_t*)((jl_uniontype_t*)v)->types);
}
else if (jl_is_typector(v)) {
n += jl_static_show(out, ((jl_typector_t*)v)->body);
}
else if (jl_is_typevar(v)) {
n += JL_PRINTF(out, "%s", ((jl_tvar_t*)v)->name->name);
}
else if (jl_is_module(v)) {
jl_module_t *m = (jl_module_t*)v;
if (m->parent != m && m->parent != jl_main_module) {
n += jl_static_show(out, (jl_value_t*)m->parent);
n += JL_PRINTF(out, ".");
}
n += JL_PRINTF(out, "%s", m->name->name);
}
else if (jl_is_symbol(v)) {
n += JL_PRINTF(out, ":%s", ((jl_sym_t*)v)->name);
}
else if (jl_is_symbolnode(v)) {
n += JL_PRINTF(out, "%s::", jl_symbolnode_sym(v)->name);
n += jl_static_show(out, jl_symbolnode_type(v));
}
else if (jl_is_getfieldnode(v)) {
n += jl_static_show(out, jl_getfieldnode_val(v));
n += JL_PRINTF(out, ".%s", jl_getfieldnode_name(v)->name);
n += JL_PRINTF(out, "::");
n += jl_static_show(out, jl_getfieldnode_type(v));
}
else if (jl_is_labelnode(v)) {
n += JL_PRINTF(out, "%d:", jl_labelnode_label(v));
}
else if (jl_is_gotonode(v)) {
n += JL_PRINTF(out, "goto %d", jl_gotonode_label(v));
}
else if (jl_is_quotenode(v)) {
n += JL_PRINTF(out, "quote ");
n += jl_static_show(out, jl_fieldref(v,0));
n += JL_PRINTF(out, " end");
}
else if (jl_is_newvarnode(v)) {
n += JL_PRINTF(out, "<newvar ");
n += jl_static_show(out, jl_fieldref(v,0));
n += JL_PRINTF(out, ">");
}
else if (jl_is_topnode(v)) {
n += JL_PRINTF(out, "top(");
n += jl_static_show(out, jl_fieldref(v,0));
n += JL_PRINTF(out, ")");
}
else if (jl_is_linenode(v)) {
n += JL_PRINTF(out, "# line %d", jl_linenode_line(v));
}
else if (jl_is_expr(v)) {
jl_expr_t *e = (jl_expr_t*)v;
if (e->head == assign_sym && jl_array_len(e->args) == 2) {
n += jl_static_show(out, jl_exprarg(e,0));
n += JL_PRINTF(out, " = ");
n += jl_static_show(out, jl_exprarg(e,1));
}
else {
char sep = ' ';
if (e->head == body_sym)
sep = '\n';
n += JL_PRINTF(out, "Expr(:%s", e->head->name);
size_t i, len = jl_array_len(e->args);
for (i = 0; i < len; i++) {
n += JL_PRINTF(out, ",%c", sep);
n += jl_static_show(out, jl_exprarg(e,i));
}
n += JL_PRINTF(out, ")::");
n += jl_static_show(out, e->etype);
}
}
else if (jl_is_array(v)) {
n += jl_static_show(out, jl_typeof(v));
n += JL_PRINTF(out, "[");
size_t j, tlen = jl_array_len(v);
for (j = 0; j < tlen; j++) {
n += jl_static_show(out, jl_arrayref((jl_array_t*)v,j));
if (j != tlen-1)
n += JL_PRINTF(out, ", ");
}
n += JL_PRINTF(out, "]");
}
else if (jl_typeis(v,jl_loaderror_type)) {
n += JL_PRINTF(out, "LoadError(at ");
n += jl_static_show(out, jl_fieldref(v, 0));
n += JL_PRINTF(out, " line ");
n += jl_static_show(out, jl_fieldref(v, 1));
n += JL_PRINTF(out, ": ");
n += jl_static_show(out, jl_fieldref(v, 2));
n += JL_PRINTF(out, ")");
}
else if (jl_typeis(v,jl_errorexception_type)) {
n += JL_PRINTF(out, "ErrorException(");
n += jl_static_show(out, jl_fieldref(v, 0));
n += JL_PRINTF(out, ")");
}
else if (jl_is_datatype(jl_typeof(v))) {
jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
n += jl_static_show(out, (jl_value_t*)t);
n += JL_PRINTF(out, "(");
size_t nb = jl_datatype_size(t);
size_t tlen = jl_tuple_len(t->names);
if (nb > 0 && tlen == 0) {
char *data = (char*)jl_data_ptr(v);
n += JL_PRINTF(out, "0x");
for(int i=nb-1; i >= 0; --i)
n += JL_PRINTF(out, "%02hhx", data[i]);
}
else {
jl_value_t *fldval=NULL;
JL_GC_PUSH1(&fldval);
for (size_t i = 0; i < tlen; i++) {
n += JL_PRINTF(out, ((jl_sym_t*)jl_tupleref(t->names, i))->name);
//jl_fielddesc_t f = t->fields[i];
n += JL_PRINTF(out, "=");
fldval = jl_get_nth_field(v, i);
n += jl_static_show(out, fldval);
if (i != tlen-1)
n += JL_PRINTF(out, ", ");
}
JL_GC_POP();
}
n += JL_PRINTF(out, ")");
}
else {
n += JL_PRINTF(out, "<?::");
n += jl_static_show(out, jl_typeof(v));
n += JL_PRINTF(out, ">");
}
return n;
}
jl_value_t *jl_resolve_globals(jl_value_t *expr, jl_module_t *module, jl_svec_t *sparam_vals)
{
if (jl_is_symbol(expr)) {
if (module == NULL)
return expr;
return jl_module_globalref(module, (jl_sym_t*)expr);
}
else if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
if (e->head == global_sym) {
// execute the side-effects of "global x" decl immediately:
// creates uninitialized mutable binding in module for each global
jl_toplevel_eval_flex(module, expr, 0, 1);
expr = jl_nothing;
}
if (jl_is_toplevel_only_expr(expr) || e->head == const_sym || e->head == copyast_sym ||
e->head == quote_sym || e->head == inert_sym ||
e->head == meta_sym || e->head == inbounds_sym ||
e->head == boundscheck_sym || e->head == simdloop_sym) {
// ignore these
}
else {
if (e->head == call_sym && jl_expr_nargs(e) == 3 &&
jl_is_quotenode(jl_exprarg(e, 2)) && module != NULL) {
// replace getfield(module_expr, :sym) with GlobalRef
jl_value_t *s = jl_fieldref(jl_exprarg(e, 2), 0);
jl_value_t *fe = jl_exprarg(e, 0);
if (jl_is_symbol(s) && jl_is_globalref(fe)) {
jl_binding_t *b = jl_get_binding(jl_globalref_mod(fe), jl_globalref_name(fe));
jl_value_t *f = NULL;
if (b && b->constp) {
f = b->value;
}
if (f == jl_builtin_getfield) {
jl_value_t *me = jl_exprarg(e, 1);
jl_module_t *me_mod = NULL;
jl_sym_t *me_sym = NULL;
if (jl_is_globalref(me)) {
me_mod = jl_globalref_mod(me);
me_sym = jl_globalref_name(me);
}
else if (jl_is_symbol(me) && jl_binding_resolved_p(module, (jl_sym_t*)me)) {
me_mod = module;
me_sym = (jl_sym_t*)me;
}
if (me_mod && me_sym) {
jl_binding_t *b = jl_get_binding(me_mod, me_sym);
if (b && b->constp) {
jl_value_t *m = b->value;
if (m && jl_is_module(m)) {
return jl_module_globalref((jl_module_t*)m, (jl_sym_t*)s);
}
}
}
}
}
}
size_t i = 0, nargs = jl_array_len(e->args);
if (e->head == foreigncall_sym) {
JL_NARGSV(ccall method definition, 5); // (fptr, rt, at, cc, narg)
jl_value_t *rt = jl_exprarg(e, 1);
jl_value_t *at = jl_exprarg(e, 2);
if (!jl_is_type(rt)) {
JL_TRY {
rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
}
JL_CATCH {
if (jl_typeis(jl_exception_in_transit, jl_errorexception_type))
jl_error("could not evaluate ccall return type (it might depend on a local variable)");
else
jl_rethrow();
}
jl_exprargset(e, 1, rt);
}
if (!jl_is_svec(at)) {
JL_TRY {
at = jl_interpret_toplevel_expr_in(module, at, NULL, sparam_vals);
}
JL_CATCH {
if (jl_typeis(jl_exception_in_transit, jl_errorexception_type))
jl_error("could not evaluate ccall argument type (it might depend on a local variable)");
else
jl_rethrow();
}
jl_exprargset(e, 2, at);
}
if (jl_is_svec(rt))
jl_error("ccall: missing return type");
JL_TYPECHK(ccall method definition, type, rt);
JL_TYPECHK(ccall method definition, simplevector, at);
JL_TYPECHK(ccall method definition, quotenode, jl_exprarg(e, 3));
JL_TYPECHK(ccall method definition, symbol, *(jl_value_t**)jl_exprarg(e, 3));
JL_TYPECHK(ccall method definition, long, jl_exprarg(e, 4));
}
DLLEXPORT void jl_set_current_module(jl_value_t *m)
{
assert(jl_typeis(m, jl_module_type));
jl_current_module = (jl_module_t*)m;
}
void jl_cell_1d_push(jl_array_t *a, jl_value_t *item)
{
assert(jl_typeis(a, jl_array_any_type));
jl_array_grow_end(a, 1);
jl_cellset(a, a->length-1, item);
}
static jl_value_t *copy_ast(jl_value_t *expr, jl_tuple_t *sp, int do_sp)
{
if (jl_is_symbol(expr)) {
if (!do_sp) return expr;
// pre-evaluate certain static parameters to help type inference
for(int i=0; i < jl_tuple_len(sp); i+=2) {
assert(jl_is_typevar(jl_tupleref(sp,i)));
if ((jl_sym_t*)expr == ((jl_tvar_t*)jl_tupleref(sp,i))->name) {
jl_value_t *spval = jl_tupleref(sp,i+1);
if (jl_is_long(spval))
return spval;
}
}
}
else if (jl_is_lambda_info(expr)) {
jl_lambda_info_t *li = (jl_lambda_info_t*)expr;
/*
if (sp == jl_null && li->ast &&
jl_array_len(jl_lam_capt((jl_expr_t*)li->ast)) == 0)
return expr;
*/
// TODO: avoid if above condition is true and decls have already
// been evaluated.
JL_GC_PUSH1(&li);
li = jl_add_static_parameters(li, sp);
// inner lambda does not need the "def" link. it leads to excess object
// retention, for example pointing to the original uncompressed AST
// of a top-level thunk that gets type inferred.
li->def = li;
li->ast = jl_prepare_ast(li, li->sparams);
JL_GC_POP();
return (jl_value_t*)li;
}
else if (jl_typeis(expr,jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)expr;
jl_array_t *na = jl_alloc_cell_1d(jl_array_len(a));
JL_GC_PUSH1(&na);
size_t i;
for(i=0; i < jl_array_len(a); i++)
jl_cellset(na, i, copy_ast(jl_cellref(a,i), sp, do_sp));
JL_GC_POP();
return (jl_value_t*)na;
}
else if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
jl_expr_t *ne = jl_exprn(e->head, jl_array_len(e->args));
JL_GC_PUSH1(&ne);
if (e->head == lambda_sym) {
jl_exprarg(ne, 0) = copy_ast(jl_exprarg(e,0), sp, 0);
jl_exprarg(ne, 1) = copy_ast(jl_exprarg(e,1), sp, 0);
jl_exprarg(ne, 2) = copy_ast(jl_exprarg(e,2), sp, 1);
}
else {
for(size_t i=0; i < jl_array_len(e->args); i++)
jl_exprarg(ne, i) = copy_ast(jl_exprarg(e,i), sp, 1);
}
JL_GC_POP();
return (jl_value_t*)ne;
}
return expr;
}
static void jl_serialize_value_(ios_t *s, jl_value_t *v)
{
if (v == NULL) {
write_uint8(s, Null_tag);
return;
}
void **bp = ptrhash_bp(&ser_tag, v);
if (*bp != HT_NOTFOUND) {
write_as_tag(s, (uint8_t)(ptrint_t)*bp);
return;
}
if (tree_literal_values) {
// compressing tree
if (!is_ast_node(v)) {
writetag(s, (jl_value_t*)LiteralVal_tag);
write_uint16(s, literal_val_id(v));
return;
}
}
else {
bp = ptrhash_bp(&backref_table, v);
if (*bp != HT_NOTFOUND) {
write_uint8(s, BackRef_tag);
write_int32(s, (ptrint_t)*bp);
return;
}
ptrhash_put(&backref_table, v, (void*)(ptrint_t)ios_pos(s));
}
size_t i;
if (jl_is_tuple(v)) {
size_t l = ((jl_tuple_t*)v)->length;
if (l <= 255) {
writetag(s, jl_tuple_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongTuple_tag);
write_int32(s, l);
}
for(i=0; i < l; i++) {
jl_serialize_value(s, jl_tupleref(v, i));
}
}
else if (jl_is_symbol(v)) {
size_t l = strlen(((jl_sym_t*)v)->name);
if (l <= 255) {
writetag(s, jl_symbol_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongSymbol_tag);
write_int32(s, l);
}
ios_write(s, ((jl_sym_t*)v)->name, l);
}
else if (jl_is_array(v)) {
jl_array_t *ar = (jl_array_t*)v;
writetag(s, (jl_value_t*)jl_array_type);
jl_serialize_value(s, ar->type);
jl_value_t *elty = jl_tparam0(ar->type);
for (i=0; i < ar->ndims; i++)
jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i)));
if (jl_is_bits_type(elty)) {
size_t tot = ar->length * ar->elsize;
ios_write(s, ar->data, tot);
}
else {
for(i=0; i < ar->length; i++) {
jl_serialize_value(s, jl_cellref(v, i));
}
}
}
else if (jl_is_expr(v)) {
jl_expr_t *e = (jl_expr_t*)v;
size_t l = e->args->length;
if (l <= 255) {
writetag(s, jl_expr_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongExpr_tag);
write_int32(s, l);
}
jl_serialize_value(s, e->head);
jl_serialize_value(s, e->etype);
for(i=0; i < l; i++) {
jl_serialize_value(s, jl_exprarg(e, i));
}
}
else if (jl_is_some_tag_type(v)) {
jl_serialize_tag_type(s, v);
}
else if (jl_is_typevar(v)) {
writetag(s, jl_tvar_type);
jl_serialize_value(s, ((jl_tvar_t*)v)->name);
jl_serialize_value(s, ((jl_tvar_t*)v)->lb);
jl_serialize_value(s, ((jl_tvar_t*)v)->ub);
write_int8(s, ((jl_tvar_t*)v)->bound);
}
else if (jl_is_function(v)) {
writetag(s, jl_func_kind);
jl_serialize_value(s, v->type);
jl_function_t *f = (jl_function_t*)v;
jl_serialize_value(s, (jl_value_t*)f->linfo);
jl_serialize_value(s, f->env);
if (f->linfo && f->linfo->ast &&
(jl_is_expr(f->linfo->ast) || jl_is_tuple(f->linfo->ast)) &&
f->fptr != &jl_trampoline) {
write_int32(s, 0);
}
else {
jl_serialize_fptr(s, f->fptr);
}
}
else if (jl_is_lambda_info(v)) {
writetag(s, jl_lambda_info_type);
jl_lambda_info_t *li = (jl_lambda_info_t*)v;
jl_serialize_value(s, li->ast);
jl_serialize_value(s, (jl_value_t*)li->sparams);
// don't save cached type info for code in the Base module, because
// it might reference types in the old System module.
if (li->module == jl_base_module)
jl_serialize_value(s, (jl_value_t*)jl_null);
else
jl_serialize_value(s, (jl_value_t*)li->tfunc);
jl_serialize_value(s, (jl_value_t*)li->name);
jl_serialize_value(s, (jl_value_t*)li->specTypes);
jl_serialize_value(s, (jl_value_t*)li->specializations);
jl_serialize_value(s, (jl_value_t*)li->inferred);
jl_serialize_value(s, (jl_value_t*)li->file);
jl_serialize_value(s, (jl_value_t*)li->line);
jl_serialize_value(s, (jl_value_t*)li->module);
}
else if (jl_typeis(v, jl_module_type)) {
jl_serialize_module(s, (jl_module_t*)v);
}
else if (jl_typeis(v, jl_methtable_type)) {
writetag(s, jl_methtable_type);
jl_methtable_t *mt = (jl_methtable_t*)v;
jl_serialize_methlist(s, mt->defs);
jl_serialize_methlist(s, mt->cache);
jl_serialize_value(s, mt->cache_1arg);
write_int32(s, mt->max_args);
}
else if (jl_typeis(v, jl_task_type)) {
jl_error("Task cannot be serialized");
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
if (jl_is_bits_type(t)) {
void *data = jl_bits_data(v);
if (t == (jl_value_t*)jl_int64_type &&
*(int64_t*)data >= S32_MIN && *(int64_t*)data <= S32_MAX) {
writetag(s, (jl_value_t*)SmallInt64_tag);
write_int32(s, (int32_t)*(int64_t*)data);
}
else {
int nb = ((jl_bits_type_t*)t)->nbits;
writetag(s, jl_bits_kind);
jl_serialize_value(s, t);
ios_write(s, data, nb/8);
}
}
else if (jl_is_struct_type(t)) {
writetag(s, jl_struct_kind);
jl_serialize_value(s, t);
size_t nf = ((jl_struct_type_t*)t)->names->length;
size_t i;
for(i=0; i < nf; i++) {
jl_value_t *fld = ((jl_value_t**)v)[i+1];
jl_serialize_value(s, fld);
}
if (t == jl_idtable_type) {
jl_cell_1d_push(idtable_list, v);
}
}
else {
assert(0);
}
}
}
DLLEXPORT void jl_cell_1d_push(jl_array_t *a, jl_value_t *item)
{
assert(jl_typeis(a, jl_array_any_type));
jl_array_grow_end(a, 1);
jl_cellset(a, jl_array_dim(a,0)-1, item);
}
JL_DLLEXPORT void jl_set_current_module(jl_value_t *m)
{
jl_ptls_t ptls = jl_get_ptls_states();
assert(jl_typeis(m, jl_module_type));
ptls->current_module = (jl_module_t*)m;
}
