jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast, int *plineno)
{
//jl_show(ex);
//JL_PRINTF(JL_STDOUT, "\n");
if (!jl_is_expr(e))
return jl_interpret_toplevel_expr(e);
jl_expr_t *ex = (jl_expr_t*)e;
if (ex->head == null_sym || ex->head == error_sym) {
// expression types simple enough not to need expansion
return jl_interpret_toplevel_expr(e);
}
if (ex->head == module_sym) {
return jl_eval_module_expr(ex, plineno);
}
// handle import, export toplevel-only forms
if (ex->head == importall_sym) {
jl_module_t *m = eval_import_path(ex->args);
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, ex->args->length-1);
assert(jl_is_symbol(name));
m = (jl_module_t*)jl_eval_global_var(m, name);
if (!jl_is_module(m))
jl_errorf("invalid import statement");
jl_module_importall(jl_current_module, m);
return jl_nothing;
}
if (ex->head == import_sym) {
jl_module_t *m = eval_import_path(ex->args);
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, ex->args->length-1);
assert(jl_is_symbol(name));
jl_module_import(jl_current_module, m, name);
return jl_nothing;
}
if (ex->head == export_sym) {
for(size_t i=0; i < ex->args->length; i++) {
jl_module_export(jl_current_module,
(jl_sym_t*)jl_cellref(ex->args, i));
}
return jl_nothing;
}
jl_value_t *thunk=NULL;
jl_value_t *result;
jl_lambda_info_t *thk=NULL;
int ewc = 0;
JL_GC_PUSH(&thunk, &thk, &ex);
if (ex->head != body_sym && ex->head != thunk_sym) {
// not yet expanded
ex = (jl_expr_t*)jl_expand(e);
}
if (jl_is_expr(ex) && ex->head == thunk_sym) {
thk = (jl_lambda_info_t*)jl_exprarg(ex,0);
assert(jl_is_lambda_info(thk));
ewc = jl_eval_with_compiler_p(jl_lam_body((jl_expr_t*)thk->ast), fast);
if (!ewc) {
jl_array_t *vinfos = jl_lam_vinfo((jl_expr_t*)thk->ast);
int i;
for(i=0; i < vinfos->length; i++) {
if (jl_vinfo_capt((jl_array_t*)jl_cellref(vinfos,i))) {
// interpreter doesn't handle closure environment
ewc = 1;
break;
}
}
}
}
else {
if (jl_is_expr(ex) && jl_eval_with_compiler_p((jl_expr_t*)ex, fast)) {
thk = jl_wrap_expr((jl_value_t*)ex);
ewc = 1;
}
else {
result = jl_interpret_toplevel_expr((jl_value_t*)ex);
JL_GC_POP();
return result;
}
}
if (ewc) {
thunk = (jl_value_t*)jl_new_closure(NULL, (jl_value_t*)jl_null, thk);
if (!jl_in_inference) {
jl_type_infer(thk, jl_tuple_type, thk);
}
result = jl_apply((jl_function_t*)thunk, NULL, 0);
}
else {
result = jl_interpret_toplevel_thunk(thk);
}
JL_GC_POP();
return result;
}
jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast)
{
//jl_show(ex);
//jl_printf(JL_STDOUT, "\n");
if (!jl_is_expr(e))
return jl_interpret_toplevel_expr(e);
jl_expr_t *ex = (jl_expr_t*)e;
if (ex->head == null_sym || ex->head == error_sym) {
// expression types simple enough not to need expansion
return jl_interpret_toplevel_expr(e);
}
if (ex->head == module_sym) {
return jl_eval_module_expr(ex);
}
// handle import, using, importall, export toplevel-only forms
if (ex->head == importall_sym) {
jl_module_t *m = eval_import_path(ex->args);
if (m==NULL) return jl_nothing;
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, jl_array_len(ex->args)-1);
if (!jl_is_symbol(name))
jl_error("syntax: malformed \"importall\" statement");
m = (jl_module_t*)jl_eval_global_var(m, name);
if (!jl_is_module(m))
jl_errorf("invalid %s statement: name exists but does not refer to a module", ex->head->name);
jl_module_importall(jl_current_module, m);
return jl_nothing;
}
if (ex->head == using_sym) {
jl_module_t *m = eval_import_path(ex->args);
if (m==NULL) return jl_nothing;
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, jl_array_len(ex->args)-1);
if (!jl_is_symbol(name))
jl_error("syntax: malformed \"using\" statement");
jl_module_t *u = (jl_module_t*)jl_eval_global_var(m, name);
if (jl_is_module(u)) {
jl_module_using(jl_current_module, u);
}
else {
jl_module_use(jl_current_module, m, name);
}
return jl_nothing;
}
if (ex->head == import_sym) {
jl_module_t *m = eval_import_path(ex->args);
if (m==NULL) return jl_nothing;
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, jl_array_len(ex->args)-1);
if (!jl_is_symbol(name))
jl_error("syntax: malformed \"import\" statement");
jl_module_import(jl_current_module, m, name);
return jl_nothing;
}
if (ex->head == export_sym) {
for(size_t i=0; i < jl_array_len(ex->args); i++) {
jl_sym_t *name = (jl_sym_t*)jl_cellref(ex->args, i);
if (!jl_is_symbol(name))
jl_error("syntax: malformed \"export\" statement");
jl_module_export(jl_current_module, name);
}
return jl_nothing;
}
if (ex->head == toplevel_sym) {
int i=0; jl_value_t *res=jl_nothing;
for(i=0; i < jl_array_len(ex->args); i++) {
res = jl_toplevel_eval_flex(jl_cellref(ex->args, i), fast);
}
return res;
}
jl_value_t *thunk=NULL;
jl_value_t *result;
jl_lambda_info_t *thk=NULL;
int ewc = 0;
JL_GC_PUSH3(&thunk, &thk, &ex);
if (ex->head != body_sym && ex->head != thunk_sym && ex->head != return_sym &&
ex->head != method_sym) {
// not yet expanded
ex = (jl_expr_t*)jl_expand(e);
}
jl_sym_t *head = jl_is_expr(ex) ? ex->head : NULL;
if (head == toplevel_sym) {
int i=0; jl_value_t *res=jl_nothing;
for(i=0; i < jl_array_len(ex->args); i++) {
res = jl_toplevel_eval_flex(jl_cellref(ex->args, i), fast);
}
JL_GC_POP();
return res;
}
if (head == thunk_sym) {
thk = (jl_lambda_info_t*)jl_exprarg(ex,0);
assert(jl_is_lambda_info(thk));
assert(jl_is_expr(thk->ast));
ewc = jl_eval_with_compiler_p((jl_expr_t*)thk->ast, jl_lam_body((jl_expr_t*)thk->ast), fast, jl_current_module);
if (!ewc) {
if (jl_lam_vars_captured((jl_expr_t*)thk->ast)) {
// interpreter doesn't handle closure environment
ewc = 1;
}
}
}
else {
if (head && jl_eval_with_compiler_p(NULL, (jl_expr_t*)ex, fast, jl_current_module)) {
thk = jl_wrap_expr((jl_value_t*)ex);
ewc = 1;
}
else {
if (head == body_sym) {
result = jl_toplevel_eval_body(ex->args);
}
else if (jl_is_toplevel_only_expr((jl_value_t*)ex)) {
result = jl_toplevel_eval((jl_value_t*)ex);
}
else {
result = jl_interpret_toplevel_expr((jl_value_t*)ex);
}
JL_GC_POP();
return result;
}
}
if (ewc) {
thunk = (jl_value_t*)jl_new_closure(NULL, (jl_value_t*)jl_emptysvec, thk);
if (!jl_in_inference) {
jl_type_infer(thk, (jl_tupletype_t*)jl_typeof(jl_emptytuple), thk);
}
result = jl_apply((jl_function_t*)thunk, NULL, 0);
}
else {
result = jl_interpret_toplevel_thunk(thk);
}
JL_GC_POP();
return result;
}
jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast,
volatile size_t *plineno)
{
//jl_show(ex);
//ios_printf(ios_stdout, "\n");
if (!jl_is_expr(e))
return jl_interpret_toplevel_expr(e);
jl_expr_t *ex = (jl_expr_t*)e;
if (ex->head == null_sym || ex->head == error_sym) {
// expression types simple enough not to need expansion
return jl_interpret_toplevel_expr(e);
}
if (ex->head == module_sym) {
return jl_eval_module_expr(ex, plineno);
}
jl_value_t *thunk=NULL;
jl_value_t *result;
jl_lambda_info_t *thk=NULL;
int ewc = 0;
JL_GC_PUSH(&thunk, &thk, &ex);
if (ex->head == body_sym || ex->head == thunk_sym) {
// already expanded
}
else {
ex = (jl_expr_t*)jl_expand(e);
}
if (jl_is_expr(ex) && ex->head == thunk_sym) {
thk = (jl_lambda_info_t*)jl_exprarg(ex,0);
assert(jl_is_lambda_info(thk));
ewc = eval_with_compiler_p(jl_lam_body((jl_expr_t*)thk->ast), fast);
if (!ewc) {
jl_array_t *vinfos = jl_lam_vinfo((jl_expr_t*)thk->ast);
int i;
for(i=0; i < vinfos->length; i++) {
if (jl_vinfo_capt((jl_array_t*)jl_cellref(vinfos,i))) {
// interpreter doesn't handle closure environment
ewc = 1;
break;
}
}
}
}
else {
if (jl_is_expr(ex) && eval_with_compiler_p((jl_expr_t*)ex, fast)) {
thk = jl_wrap_expr((jl_value_t*)ex);
ewc = 1;
}
else {
result = jl_interpret_toplevel_expr((jl_value_t*)ex);
JL_GC_POP();
return result;
}
}
if (ewc) {
thunk = jl_new_closure_internal(thk, (jl_value_t*)jl_null);
if (fast && !jl_in_inference) {
jl_type_infer(thk, jl_tuple_type, thk);
}
result = jl_apply((jl_function_t*)thunk, NULL, 0);
}
else {
result = jl_interpret_toplevel_thunk(thk);
}
JL_GC_POP();
return result;
}
static jl_function_t *cache_method(jl_methtable_t *mt, jl_tuple_t *type,
jl_function_t *method, jl_tuple_t *decl,
jl_tuple_t *sparams)
{
size_t i;
int need_dummy_entries = 0;
jl_value_t *temp=NULL;
jl_function_t *newmeth=NULL;
JL_GC_PUSH(&type, &temp, &newmeth);
for (i=0; i < type->length; i++) {
jl_value_t *elt = jl_tupleref(type,i);
int set_to_any = 0;
if (nth_slot_type(decl,i) == jl_ANY_flag) {
// don't specialize on slots marked ANY
temp = jl_tupleref(type, i);
jl_tupleset(type, i, (jl_value_t*)jl_any_type);
int nintr=0;
jl_methlist_t *curr = mt->defs;
// if this method is the only match even with the current slot
// set to Any, then it is safe to cache it that way.
while (curr != NULL && curr->func!=method) {
if (jl_type_intersection((jl_value_t*)curr->sig,
(jl_value_t*)type) !=
(jl_value_t*)jl_bottom_type) {
nintr++;
break;
}
curr = curr->next;
}
if (nintr) {
// TODO: even if different specializations of this slot need
// separate cache entries, have them share code.
jl_tupleset(type, i, temp);
}
else {
set_to_any = 1;
}
}
if (set_to_any) {
}
else if (jl_is_tuple(elt)) {
/*
don't cache tuple type exactly; just remember that it was
a tuple, unless the declaration asks for something more
specific. determined with a type intersection.
*/
int might_need_dummy=0;
temp = jl_tupleref(type, i);
if (i < decl->length) {
jl_value_t *declt = jl_tupleref(decl,i);
// for T..., intersect with T
if (jl_is_seq_type(declt))
declt = jl_tparam0(declt);
if (declt == (jl_value_t*)jl_tuple_type ||
jl_subtype((jl_value_t*)jl_tuple_type, declt, 0)) {
// don't specialize args that matched (Any...) or Any
jl_tupleset(type, i, (jl_value_t*)jl_tuple_type);
might_need_dummy = 1;
}
else {
declt = jl_type_intersection(declt,
(jl_value_t*)jl_tuple_type);
if (((jl_tuple_t*)elt)->length > 3 ||
tuple_all_Any((jl_tuple_t*)declt)) {
jl_tupleset(type, i, declt);
might_need_dummy = 1;
}
}
}
else {
jl_tupleset(type, i, (jl_value_t*)jl_tuple_type);
might_need_dummy = 1;
}
assert(jl_tupleref(type,i) != (jl_value_t*)jl_bottom_type);
if (might_need_dummy) {
jl_methlist_t *curr = mt->defs;
// can't generalize type if there's an overlapping definition
// with typevars
while (curr != NULL && curr->func!=method) {
if (curr->tvars!=jl_null &&
jl_type_intersection((jl_value_t*)curr->sig,
(jl_value_t*)type) !=
(jl_value_t*)jl_bottom_type) {
jl_tupleset(type, i, temp);
might_need_dummy = 0;
break;
}
curr = curr->next;
}
}
if (might_need_dummy) {
jl_methlist_t *curr = mt->defs;
while (curr != NULL && curr->func!=method) {
jl_tuple_t *sig = curr->sig;
if (sig->length > i &&
jl_is_tuple(jl_tupleref(sig,i))) {
need_dummy_entries = 1;
break;
}
curr = curr->next;
}
}
}
else if (jl_is_type_type(elt) && jl_is_type_type(jl_tparam0(elt))) {
/*
actual argument was Type{...}, we computed its type as
Type{Type{...}}. we must avoid unbounded nesting here, so
cache the signature as Type{T}, unless something more
specific like Type{Type{Int32}} was actually declared.
this can be determined using a type intersection.
*/
if (i < decl->length) {
jl_value_t *declt = jl_tupleref(decl,i);
// for T..., intersect with T
if (jl_is_seq_type(declt))
declt = jl_tparam0(declt);
jl_tupleset(type, i,
jl_type_intersection(declt, (jl_value_t*)jl_typetype_type));
}
else {
jl_tupleset(type, i, (jl_value_t*)jl_typetype_type);
}
assert(jl_tupleref(type,i) != (jl_value_t*)jl_bottom_type);
}
else if (jl_is_type_type(elt) &&
very_general_type(nth_slot_type(decl,i))) {
/*
here's a fairly complex heuristic: if this argument slot's
declared type is Any, and no definition overlaps with Type
for this slot, then don't specialize for every Type that
might be passed.
Since every type x has its own type Type{x}, this would be
excessive specialization for an Any slot.
*/
int ok=1;
jl_methlist_t *curr = mt->defs;
while (curr != NULL) {
jl_value_t *slottype = nth_slot_type(curr->sig, i);
if (slottype &&
!very_general_type(slottype) &&
jl_type_intersection(slottype,
(jl_value_t*)jl_type_type) !=
(jl_value_t*)jl_bottom_type) {
ok=0;
break;
}
curr = curr->next;
}
if (ok) {
jl_tupleset(type, i, (jl_value_t*)jl_typetype_type);
}
}
}
// for varargs methods, only specialize up to max_args.
// in general, here we want to find the biggest type that's not a
// supertype of any other method signatures. so far we are conservative
// and the types we find should be bigger.
if (type->length > jl_unbox_long(mt->max_args) &&
jl_is_seq_type(jl_tupleref(decl,decl->length-1))) {
size_t nspec = jl_unbox_long(mt->max_args)+2;
jl_tuple_t *limited = jl_alloc_tuple(nspec);
for(i=0; i < nspec-1; i++) {
jl_tupleset(limited, i, jl_tupleref(type, i));
}
jl_value_t *lasttype = jl_tupleref(type,i-1);
// if all subsequent arguments are subtypes of lasttype, specialize
// on that instead of decl. for example, if decl is
// (Any...)
// and type is
// (Symbol, Symbol, Symbol)
// then specialize as (Symbol...), but if type is
// (Symbol, Int32, Expr)
// then specialize as (Any...)
size_t j = i;
int all_are_subtypes=1;
for(; j < type->length; j++) {
if (!jl_subtype(jl_tupleref(type,j), lasttype, 0)) {
all_are_subtypes = 0;
break;
}
}
type = limited;
if (all_are_subtypes) {
// avoid Type{Type{...}...}...
if (jl_is_type_type(lasttype))
lasttype = (jl_value_t*)jl_type_type;
temp = (jl_value_t*)jl_tuple1(lasttype);
jl_tupleset(type, i, jl_apply_type((jl_value_t*)jl_seq_type,
(jl_tuple_t*)temp));
}
else {
jl_value_t *lastdeclt = jl_tupleref(decl,decl->length-1);
if (sparams->length > 0) {
lastdeclt = (jl_value_t*)
jl_instantiate_type_with((jl_type_t*)lastdeclt,
sparams->data,
sparams->length/2);
}
jl_tupleset(type, i, lastdeclt);
}
// now there is a problem: the computed signature is more
// general than just the given arguments, so it might conflict
// with another definition that doesn't have cache instances yet.
// to fix this, we insert dummy cache entries for all intersections
// of this signature and definitions. those dummy entries will
// supersede this one in conflicted cases, alerting us that there
// should actually be a cache miss.
need_dummy_entries = 1;
}
if (need_dummy_entries) {
temp = ml_matches(mt->defs, (jl_value_t*)type, lambda_sym, -1);
for(i=0; i < jl_array_len(temp); i++) {
jl_value_t *m = jl_cellref(temp, i);
if (jl_tupleref(m,2) != (jl_value_t*)method->linfo) {
jl_method_cache_insert(mt, (jl_tuple_t*)jl_tupleref(m, 0),
NULL);
}
}
}
// here we infer types and specialize the method
/*
if (sparams==jl_null)
newmeth = method;
else
*/
jl_array_t *lilist=NULL;
jl_lambda_info_t *li=NULL;
if (method->linfo && method->linfo->specializations!=NULL) {
// reuse code already generated for this combination of lambda and
// arguments types. this happens for inner generic functions where
// a new closure is generated on each call to the enclosing function.
lilist = method->linfo->specializations;
int k;
for(k=0; k < lilist->length; k++) {
li = (jl_lambda_info_t*)jl_cellref(lilist, k);
if (jl_types_equal(li->specTypes, (jl_value_t*)type))
break;
}
if (k == lilist->length) lilist=NULL;
}
if (lilist != NULL && !li->inInference) {
assert(li);
newmeth = jl_reinstantiate_method(method, li);
(void)jl_method_cache_insert(mt, type, newmeth);
JL_GC_POP();
return newmeth;
}
else {
newmeth = jl_instantiate_method(method, sparams);
}
/*
if "method" itself can ever be compiled, for example for use as
an unspecialized method (see below), then newmeth->fptr might point
to some slow compiled code instead of jl_trampoline, meaning our
type-inferred code would never get compiled. this can be fixed with
the commented-out snippet below.
*/
assert(!(newmeth->linfo && newmeth->linfo->ast) ||
newmeth->fptr == &jl_trampoline);
/*
if (newmeth->linfo&&newmeth->linfo->ast&&newmeth->fptr!=&jl_trampoline) {
newmeth->fptr = &jl_trampoline;
}
*/
(void)jl_method_cache_insert(mt, type, newmeth);
if (newmeth->linfo != NULL && newmeth->linfo->sparams == jl_null) {
// when there are no static parameters, one unspecialized version
// of a function can be shared among all cached specializations.
if (method->linfo->unspecialized == NULL) {
method->linfo->unspecialized =
jl_instantiate_method(method, jl_null);
}
newmeth->linfo->unspecialized = method->linfo->unspecialized;
}
if (newmeth->linfo != NULL && newmeth->linfo->ast != NULL) {
newmeth->linfo->specTypes = (jl_value_t*)type;
jl_array_t *spe = method->linfo->specializations;
if (spe == NULL) {
spe = jl_alloc_cell_1d(1);
jl_cellset(spe, 0, newmeth->linfo);
}
else {
jl_cell_1d_push(spe, (jl_value_t*)newmeth->linfo);
}
method->linfo->specializations = spe;
jl_type_infer(newmeth->linfo, type, method->linfo);
}
JL_GC_POP();
return newmeth;
}
