value_t fl_defined_julia_global(value_t *args, uint32_t nargs)
{
argcount("defined-julia-global", nargs, 1);
(void)tosymbol(args[0], "defined-julia-global");
char *name = symbol_name(args[0]);
return jl_boundp(jl_current_module, jl_symbol(name)) ? FL_T : FL_F;
}
static void symtab_search(jl_sym_t *tree, int *pcount, ios_t *result,
const char *prefix, int plen)
{
do {
if (common_prefix(prefix, tree->name) == plen &&
jl_boundp(jl_system_module, tree)) {
ios_puts(tree->name, result);
ios_putc('\n', result);
(*pcount)++;
}
if (tree->left)
symtab_search(tree->left, pcount, result, prefix, plen);
tree = tree->right;
} while (tree != NULL);
}
static void symtab_search(jl_sym_t *tree, int *pcount, ios_t *result,
jl_module_t *module, const char *str,
const char *prefix, int plen)
{
do {
if (common_prefix(prefix, tree->name) == plen &&
(module ? jl_defines_or_exports_p(module, tree) : jl_boundp(jl_current_module, tree))) {
ios_puts(str, result);
ios_puts(tree->name + plen, result);
ios_putc('\n', result);
(*pcount)++;
}
if (tree->left)
symtab_search(tree->left, pcount, result, module, str, prefix, plen);
tree = tree->right;
} while (tree != NULL);
}
/*
static void clear_method_caches(void)
{
htable_t *t = &jl_system_module->bindings;
size_t i;
for(i=0; i < t->size; i+=2) {
if (t->table[i+1] == HT_NOTFOUND)
continue;
jl_binding_t *b = (jl_binding_t*)t->table[i+1];
if (b->value != NULL && jl_is_func(b->value) && jl_is_gf(b->value)) {
jl_function_t *f = (jl_function_t*)b->value;
jl_methtable_t *mt = jl_gf_mtable(f);
mt->cache = NULL;
}
}
}
*/
DLLEXPORT void jl_enable_inference(void)
{
if (jl_boundp(jl_system_module, jl_symbol("typeinf_ext"))) {
//clear_method_caches();
jl_typeinf_func =
(jl_function_t*)*(jl_get_bindingp(jl_system_module,
jl_symbol("typeinf_ext")));
// warm up type inference to put the latency up front
jl_value_t *one = jl_box_long(1);
jl_apply((jl_function_t*)*(jl_get_bindingp(jl_system_module,
jl_symbol("+"))),
&one, 1);
/*
cached t-functions and inferred ASTs need to be cleared at
this point, because during bootstrapping we might not be
able to inline optimally. the reason is that we cache an AST
before doing inlining, to prevent infinite recursion.
for example, consider this function:
> (x::Real, y::Real) = (y < x)
after doing inference on this >, we cache its AST "(y < x)".
now we begin inlining. the problem is that the inlining code
itself will trigger compilation of functions that use >, so
"(y < x)" will be inlined into those functions. ultimately
we inline the definition of < into "(y < x)", but by then it's
too late, since "(y < x)" has already been inlined into some
functions.
to fix this, we clear the t-function cache after all
type-inference related code has been compiled. now we can
inline everything fully without compilation of the compiler
itself interfering.
*/
clear_tfunc_caches();
}
}
static jl_value_t *eval(jl_value_t *e, interpreter_state *s)
{
jl_ptls_t ptls = jl_get_ptls_states();
jl_code_info_t *src = s->src;
if (jl_is_ssavalue(e)) {
ssize_t id = ((jl_ssavalue_t*)e)->id;
if (src == NULL || id >= jl_source_nssavalues(src) || id < 0 || s->locals == NULL)
jl_error("access to invalid SSAValue");
else
return s->locals[jl_source_nslots(src) + id];
}
if (jl_is_slot(e)) {
ssize_t n = jl_slot_number(e);
if (src == NULL || n > jl_source_nslots(src) || n < 1 || s->locals == NULL)
jl_error("access to invalid slot number");
jl_value_t *v = s->locals[n - 1];
if (v == NULL)
jl_undefined_var_error((jl_sym_t*)jl_array_ptr_ref(src->slotnames, n - 1));
return v;
}
if (jl_is_globalref(e)) {
return jl_eval_global_var(jl_globalref_mod(e), jl_globalref_name(e));
}
if (jl_is_quotenode(e))
return jl_fieldref(e,0);
jl_module_t *modu = s->module;
if (jl_is_symbol(e)) { // bare symbols appear in toplevel exprs not wrapped in `thunk`
return jl_eval_global_var(modu, (jl_sym_t*)e);
}
if (!jl_is_expr(e))
return e;
jl_expr_t *ex = (jl_expr_t*)e;
jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
size_t nargs = jl_array_len(ex->args);
if (ex->head == isdefined_sym) {
jl_value_t *sym = args[0];
int defined = 0;
if (jl_is_slot(sym)) {
ssize_t n = jl_slot_number(sym);
if (src == NULL || n > jl_source_nslots(src) || n < 1 || s->locals == NULL)
jl_error("access to invalid slot number");
defined = s->locals[n - 1] != NULL;
}
else if (jl_is_globalref(sym)) {
defined = jl_boundp(jl_globalref_mod(sym), jl_globalref_name(sym));
}
else if (jl_is_symbol(sym)) {
defined = jl_boundp(modu, (jl_sym_t*)sym);
}
else if (jl_is_expr(sym) && ((jl_expr_t*)sym)->head == static_parameter_sym) {
ssize_t n = jl_unbox_long(args[0]);
assert(n > 0);
if (s->sparam_vals && n <= jl_svec_len(s->sparam_vals)) {
jl_value_t *sp = jl_svecref(s->sparam_vals, n - 1);
defined = !jl_is_typevar(sp);
}
else {
// static parameter val unknown needs to be an error for ccall
jl_error("could not determine static parameter value");
}
}
else {
assert(0 && "malformed isdefined expression");
}
return defined ? jl_true : jl_false;
}
else if (ex->head == call_sym) {
return do_call(args, nargs, s);
}
else if (ex->head == invoke_sym) {
return do_invoke(args, nargs, s);
}
else if (ex->head == new_sym) {
jl_value_t *thetype = eval(args[0], s);
jl_value_t *v=NULL;
JL_GC_PUSH2(&thetype, &v);
assert(jl_is_structtype(thetype));
v = jl_new_struct_uninit((jl_datatype_t*)thetype);
for (size_t i = 1; i < nargs; i++) {
jl_value_t *ft = jl_field_type(thetype, i - 1);
jl_value_t *fldv = eval(args[i], s);
if (!jl_isa(fldv, ft))
jl_type_error("new", ft, fldv);
jl_set_nth_field(v, i - 1, fldv);
}
JL_GC_POP();
return v;
}
else if (ex->head == static_parameter_sym) {
ssize_t n = jl_unbox_long(args[0]);
assert(n > 0);
if (s->sparam_vals && n <= jl_svec_len(s->sparam_vals)) {
jl_value_t *sp = jl_svecref(s->sparam_vals, n - 1);
if (jl_is_typevar(sp) && !s->preevaluation)
jl_undefined_var_error(((jl_tvar_t*)sp)->name);
return sp;
}
// static parameter val unknown needs to be an error for ccall
jl_error("could not determine static parameter value");
}
else if (ex->head == inert_sym) {
return args[0];
}
else if (ex->head == copyast_sym) {
return jl_copy_ast(eval(args[0], s));
}
else if (ex->head == exc_sym) {
return ptls->exception_in_transit;
}
else if (ex->head == method_sym) {
jl_sym_t *fname = (jl_sym_t*)args[0];
if (jl_is_globalref(fname)) {
modu = jl_globalref_mod(fname);
fname = jl_globalref_name(fname);
}
assert(jl_expr_nargs(ex) != 1 || jl_is_symbol(fname));
if (jl_is_symbol(fname)) {
jl_value_t *bp_owner = (jl_value_t*)modu;
jl_binding_t *b = jl_get_binding_for_method_def(modu, fname);
jl_value_t **bp = &b->value;
jl_value_t *gf = jl_generic_function_def(b->name, b->owner, bp, bp_owner, b);
if (jl_expr_nargs(ex) == 1)
return gf;
}
jl_value_t *atypes = NULL, *meth = NULL;
JL_GC_PUSH2(&atypes, &meth);
atypes = eval(args[1], s);
meth = eval(args[2], s);
jl_method_def((jl_svec_t*)atypes, (jl_code_info_t*)meth, s->module, args[3]);
JL_GC_POP();
return jl_nothing;
}
else if (ex->head == const_sym) {
jl_sym_t *sym = (jl_sym_t*)args[0];
if (jl_is_globalref(sym)) {
modu = jl_globalref_mod(sym);
sym = jl_globalref_name(sym);
}
assert(jl_is_symbol(sym));
jl_binding_t *b = jl_get_binding_wr(modu, sym, 1);
jl_declare_constant(b);
return (jl_value_t*)jl_nothing;
}
else if (ex->head == abstracttype_sym) {
if (inside_typedef)
jl_error("cannot eval a new abstract type definition while defining another type");
jl_value_t *name = args[0];
jl_value_t *para = eval(args[1], s);
jl_value_t *super = NULL;
jl_value_t *temp = NULL;
jl_datatype_t *dt = NULL;
jl_value_t *w = NULL;
JL_GC_PUSH4(¶, &super, &temp, &w);
assert(jl_is_svec(para));
if (jl_is_globalref(name)) {
modu = jl_globalref_mod(name);
name = (jl_value_t*)jl_globalref_name(name);
}
assert(jl_is_symbol(name));
dt = jl_new_abstracttype(name, modu, NULL, (jl_svec_t*)para);
w = dt->name->wrapper;
jl_binding_t *b = jl_get_binding_wr(modu, (jl_sym_t*)name, 1);
temp = b->value;
check_can_assign_type(b, w);
b->value = w;
jl_gc_wb_binding(b, w);
JL_TRY {
inside_typedef = 1;
super = eval(args[2], s);
jl_set_datatype_super(dt, super);
jl_reinstantiate_inner_types(dt);
}
JL_CATCH {
jl_reset_instantiate_inner_types(dt);
b->value = temp;
jl_rethrow();
}
b->value = temp;
if (temp == NULL || !equiv_type(dt, (jl_datatype_t*)jl_unwrap_unionall(temp))) {
jl_checked_assignment(b, w);
}
JL_GC_POP();
return (jl_value_t*)jl_nothing;
}
else if (ex->head == primtype_sym) {
