JL_DLLEXPORT jl_module_t *jl_new_main_module(void)
{
jl_ptls_t ptls = jl_get_ptls_states();
if (jl_generating_output() && jl_options.incremental)
jl_error("cannot call workspace() in incremental compile mode");
// switch to a new top-level module
if (ptls->current_module != jl_main_module &&
ptls->current_module != NULL && jl_main_module != NULL)
jl_error("Main can only be replaced from the top level");
jl_module_t *old_main = jl_main_module;
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
if (old_main) { // don't block continued loading of incremental caches
jl_main_module->primary_world = old_main->primary_world;
jl_main_module->build_id = old_main->build_id;
jl_main_module->uuid = old_main->uuid;
}
ptls->current_module = jl_main_module;
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_set_global(jl_core_module, jl_symbol("Main"),
(jl_value_t*)jl_main_module);
ptls->current_task->current_module = jl_main_module;
return old_main;
}
jl_module_t *jl_new_main_module(void)
{
if (jl_generating_output() && jl_options.incremental)
jl_error("cannot call workspace() in incremental compile mode");
// switch to a new top-level module
if (jl_current_module != jl_main_module && jl_current_module != NULL)
jl_error("Main can only be replaced from the top level");
jl_module_t *old_main = jl_main_module;
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
if (old_main) // don't block continued loading of incremental caches
jl_main_module->uuid = old_main->uuid;
jl_current_module = jl_main_module;
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_set_global(jl_core_module, jl_symbol("Main"),
(jl_value_t*)jl_main_module);
jl_current_task->current_module = jl_main_module;
jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
return old_main;
}
DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
{
jl_module_t *m = jl_new_module(name);
JL_GC_PUSH1(&m);
m->parent = jl_main_module;
jl_gc_wb(m, m->parent);
if (std_imports) jl_add_standard_imports(m);
JL_GC_POP();
return (jl_value_t*)m;
}
JL_DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
{
// TODO: should we prohibit this during incremental compilation?
jl_module_t *m = jl_new_module(name);
JL_GC_PUSH1(&m);
m->parent = jl_main_module; // TODO: this is a lie
jl_gc_wb(m, m->parent);
if (std_imports)
jl_add_standard_imports(m);
JL_GC_POP();
// TODO: should we somehow try to gc-root this correctly?
return (jl_value_t*)m;
}
// create a new top-level module
void jl_init_main_module(void)
{
if (jl_main_module != NULL)
jl_error("Main module already initialized.");
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_set_global(jl_core_module, jl_symbol("Main"),
(jl_value_t*)jl_main_module);
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex, int *plineno)
{
assert(ex->head == module_sym);
jl_module_t *last_module = jl_current_module;
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 0);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
if (name == jl_current_module->name) {
jl_errorf("module name %s conflicts with enclosing module", name->name);
}
jl_binding_t *b = jl_get_binding_wr(jl_current_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
JL_PRINTF(JL_STDERR, "Warning: redefinition of module %s ignored\n",
name->name);
return jl_nothing;
}
jl_module_t *newm = jl_new_module(name);
b->value = (jl_value_t*)newm;
if (jl_current_module == jl_core_module && name == jl_symbol("Base")) {
// pick up Base module during bootstrap, and stay within it
// after loading.
jl_base_module = last_module = newm;
}
JL_GC_PUSH(&last_module);
jl_current_module = newm;
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 1))->args;
JL_TRY {
for(int i=0; i < exprs->length; i++) {
// process toplevel form
jl_value_t *form = jl_cellref(exprs, i);
if (jl_is_linenode(form)) {
if (plineno)
*plineno = jl_linenode_line(form);
}
else {
(void)jl_toplevel_eval_flex(form, 0, plineno);
}
}
}
JL_CATCH {
JL_GC_POP();
jl_current_module = last_module;
jl_raise(jl_exception_in_transit);
}
JL_GC_POP();
jl_current_module = last_module;
return jl_nothing;
}
jl_module_t *jl_new_main_module(void)
{
// switch to a new top-level module
if (jl_current_module != jl_main_module && jl_current_module != NULL)
jl_error("Main can only be replaced from the top level");
jl_module_t *old_main = jl_main_module;
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
jl_current_module = jl_main_module;
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_set_global(jl_core_module, jl_symbol("Main"),
(jl_value_t*)jl_main_module);
jl_current_task->current_module = jl_main_module;
return old_main;
}
static jl_value_t *jl_deserialize_value(ios_t *s)
{
int pos = ios_pos(s);
int32_t tag = read_uint8(s);
if (tag == Null_tag)
return NULL;
if (tag == 0) {
tag = read_uint8(s);
return (jl_value_t*)ptrhash_get(&deser_tag, (void*)(ptrint_t)tag);
}
if (tag == BackRef_tag) {
assert(tree_literal_values == NULL);
ptrint_t offs = read_int32(s);
void **bp = ptrhash_bp(&backref_table, (void*)(ptrint_t)offs);
assert(*bp != HT_NOTFOUND);
return (jl_value_t*)*bp;
}
jl_value_t *vtag=(jl_value_t*)ptrhash_get(&deser_tag,(void*)(ptrint_t)tag);
if (tag >= VALUE_TAGS) {
return vtag;
}
int usetable = (tree_literal_values == NULL);
size_t i;
if (vtag == (jl_value_t*)jl_tuple_type ||
vtag == (jl_value_t*)LongTuple_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_tuple_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_tuple_t *tu = jl_alloc_tuple_uninit(len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)tu);
for(i=0; i < len; i++)
jl_tupleset(tu, i, jl_deserialize_value(s));
return (jl_value_t*)tu;
}
else if (vtag == (jl_value_t*)jl_symbol_type ||
vtag == (jl_value_t*)LongSymbol_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_symbol_type)
len = read_uint8(s);
else
len = read_int32(s);
char *name = alloca(len+1);
ios_read(s, name, len);
name[len] = '\0';
jl_value_t *s = (jl_value_t*)jl_symbol(name);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, s);
return s;
}
else if (vtag == (jl_value_t*)jl_array_type) {
jl_value_t *aty = jl_deserialize_value(s);
jl_value_t *elty = jl_tparam0(aty);
int16_t ndims = jl_unbox_long(jl_tparam1(aty));
size_t *dims = alloca(ndims*sizeof(size_t));
for(i=0; i < ndims; i++)
dims[i] = jl_unbox_long(jl_deserialize_value(s));
jl_array_t *a = jl_new_array_((jl_type_t*)aty, ndims, dims);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)a);
if (jl_is_bits_type(elty)) {
size_t tot = a->length * a->elsize;
ios_read(s, a->data, tot);
}
else {
for(i=0; i < a->length; i++) {
((jl_value_t**)a->data)[i] = jl_deserialize_value(s);
}
}
return (jl_value_t*)a;
}
else if (vtag == (jl_value_t*)jl_expr_type ||
vtag == (jl_value_t*)LongExpr_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_expr_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s), len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)e);
e->etype = jl_deserialize_value(s);
for(i=0; i < len; i++) {
jl_cellset(e->args, i, jl_deserialize_value(s));
}
return (jl_value_t*)e;
}
else if (vtag == (jl_value_t*)LiteralVal_tag) {
return jl_cellref(tree_literal_values, read_uint16(s));
}
else if (vtag == (jl_value_t*)jl_tvar_type) {
jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_type_t*)jl_tvar_type, 4);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, tv);
tv->name = (jl_sym_t*)jl_deserialize_value(s);
tv->lb = jl_deserialize_value(s);
tv->ub = jl_deserialize_value(s);
tv->bound = read_int8(s);
return (jl_value_t*)tv;
}
else if (vtag == (jl_value_t*)jl_func_kind) {
jl_value_t *ftype = jl_deserialize_value(s);
jl_function_t *f = (jl_function_t*)newobj((jl_type_t*)ftype, 3);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, f);
f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s);
f->env = jl_deserialize_value(s);
f->fptr = jl_deserialize_fptr(s);
if (f->fptr == NULL) {
f->fptr = &jl_trampoline;
}
return (jl_value_t*)f;
}
else if (vtag == (jl_value_t*)jl_lambda_info_type) {
jl_lambda_info_t *li =
(jl_lambda_info_t*)newobj((jl_type_t*)jl_lambda_info_type,
LAMBDA_INFO_NW);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, li);
li->ast = jl_deserialize_value(s);
li->sparams = (jl_tuple_t*)jl_deserialize_value(s);
li->tfunc = jl_deserialize_value(s);
li->name = (jl_sym_t*)jl_deserialize_value(s);
li->specTypes = jl_deserialize_value(s);
li->specializations = (jl_array_t*)jl_deserialize_value(s);
li->inferred = jl_deserialize_value(s);
li->file = jl_deserialize_value(s);
li->line = jl_deserialize_value(s);
li->module = (jl_module_t*)jl_deserialize_value(s);
li->fptr = NULL;
li->roots = NULL;
li->functionObject = NULL;
li->inInference = 0;
li->inCompile = 0;
li->unspecialized = NULL;
return (jl_value_t*)li;
}
else if (vtag == (jl_value_t*)jl_module_type) {
jl_module_t *m = jl_new_module(anonymous_sym);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, m);
m->name = (jl_sym_t*)jl_deserialize_value(s);
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_binding_t *b = jl_get_binding_wr(m, (jl_sym_t*)name);
b->value = jl_deserialize_value(s);
b->type = (jl_type_t*)jl_deserialize_value(s);
b->constp = read_int8(s);
b->exportp = read_int8(s);
}
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_set_expander(m, (jl_sym_t*)name,
(jl_function_t*)jl_deserialize_value(s));
}
return (jl_value_t*)m;
}
else if (vtag == (jl_value_t*)jl_methtable_type) {
jl_methtable_t *mt = (jl_methtable_t*)allocobj(sizeof(jl_methtable_t));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, mt);
mt->type = (jl_type_t*)jl_methtable_type;
mt->defs = jl_deserialize_methlist(s);
mt->cache = jl_deserialize_methlist(s);
mt->cache_1arg = (jl_array_t*)jl_deserialize_value(s);
mt->max_args = read_int32(s);
return (jl_value_t*)mt;
}
else if (vtag == (jl_value_t*)SmallInt64_tag) {
jl_value_t *v = jl_box_int64(read_int32(s));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_bits_kind) {
jl_bits_type_t *bt = (jl_bits_type_t*)jl_deserialize_value(s);
int nby = bt->nbits/8;
char *data = alloca(nby);
ios_read(s, data, nby);
jl_value_t *v=NULL;
if (bt == jl_int32_type)
v = jl_box_int32(*(int32_t*)data);
else if (bt == jl_int64_type)
v = jl_box_int64(*(int64_t*)data);
else if (bt == jl_bool_type)
v = jl_box_bool(*(int8_t*)data);
else {
switch (bt->nbits) {
case 8: v = jl_box8 (bt, *(int8_t*) data); break;
case 16: v = jl_box16(bt, *(int16_t*)data); break;
case 32: v = jl_box32(bt, *(int32_t*)data); break;
case 64: v = jl_box64(bt, *(int64_t*)data); break;
default:
v = (jl_value_t*)allocobj(sizeof(void*)+nby);
v->type = (jl_type_t*)bt;
memcpy(jl_bits_data(v), data, nby);
}
}
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_struct_kind) {
jl_struct_type_t *typ = (jl_struct_type_t*)jl_deserialize_value(s);
if (typ == jl_struct_kind || typ == jl_bits_kind)
return jl_deserialize_tag_type(s, typ, pos);
size_t nf = typ->names->length;
jl_value_t *v = jl_new_struct_uninit(typ);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
for(i=0; i < nf; i++) {
((jl_value_t**)v)[i+1] = jl_deserialize_value(s);
}
// TODO: put WeakRefs on the weak_refs list
return v;
}
else if (vtag == (jl_value_t*)jl_tag_kind) {
return jl_deserialize_tag_type(s, jl_tag_kind, pos);
}
assert(0);
return NULL;
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
{
static arraylist_t module_stack;
static int initialized=0;
static jl_module_t *outermost = NULL;
if (!initialized) {
arraylist_new(&module_stack, 0);
initialized = 1;
}
assert(ex->head == module_sym);
jl_module_t *last_module = jl_current_module;
if (jl_array_len(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex,2))) {
jl_error("syntax: malformed module expression");
}
int std_imports = (jl_exprarg(ex,0)==jl_true);
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 1);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *parent_module = jl_current_module;
jl_binding_t *b = jl_get_binding_wr(parent_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
if (!jl_is_module(b->value)) {
jl_errorf("invalid redefinition of constant %s", name->name);
}
if (jl_generating_output() && jl_options.incremental) {
jl_errorf("cannot replace module %s during incremental compile", name->name);
}
if (!jl_generating_output()) {
// suppress warning "replacing module Core.Inference" during bootstrapping
jl_printf(JL_STDERR, "WARNING: replacing module %s\n", name->name);
}
}
jl_module_t *newm = jl_new_module(name);
newm->parent = parent_module;
b->value = (jl_value_t*)newm;
jl_gc_wb_binding(b, newm);
if (parent_module == jl_main_module && name == jl_symbol("Base")) {
// pick up Base module during bootstrap
jl_old_base_module = jl_base_module;
jl_base_module = newm;
// reinitialize global variables
// to pick up new types from Base
jl_errorexception_type = NULL;
jl_argumenterror_type = NULL;
jl_methoderror_type = NULL;
jl_loaderror_type = NULL;
jl_current_task->tls = jl_nothing; // may contain an entry for :SOURCE_FILE that is not valid in the new base
}
// export all modules from Main
if (parent_module == jl_main_module)
jl_module_export(jl_main_module, name);
// add standard imports unless baremodule
if (std_imports) {
if (jl_base_module != NULL) {
jl_add_standard_imports(newm);
}
}
JL_GC_PUSH1(&last_module);
jl_module_t *task_last_m = jl_current_task->current_module;
jl_current_task->current_module = jl_current_module = newm;
jl_module_t *prev_outermost = outermost;
size_t stackidx = module_stack.len;
if (outermost == NULL)
outermost = newm;
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
JL_TRY {
for(int i=0; i < jl_array_len(exprs); i++) {
// process toplevel form
jl_value_t *form = jl_cellref(exprs, i);
(void)jl_toplevel_eval_flex(form, 1);
}
}
JL_CATCH {
jl_current_module = last_module;
jl_current_task->current_module = task_last_m;
outermost = prev_outermost;
module_stack.len = stackidx;
jl_rethrow();
}
JL_GC_POP();
jl_current_module = last_module;
jl_current_task->current_module = task_last_m;
outermost = prev_outermost;
#if 0
// some optional post-processing steps
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (b->name->name[0]=='@' && !b->exportp && b->owner==newm)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
b->name->name, newm->name->name);
*/
}
}
#endif
arraylist_push(&module_stack, newm);
if (outermost == NULL || jl_current_module == jl_main_module) {
size_t i, l=module_stack.len;
for(i = stackidx; i < l; i++) {
jl_module_load_time_initialize((jl_module_t*)module_stack.items[i]);
}
assert(module_stack.len == l);
module_stack.len = stackidx;
}
return (jl_value_t*)newm;
}
static jl_value_t *jl_deserialize_value(ios_t *s)
{
int pos = ios_pos(s);
int32_t tag = read_uint8(s);
if (tag == Null_tag)
return NULL;
if (tag == 0) {
tag = read_uint8(s);
jl_value_t *v = ptrhash_get(&deser_tag, (void*)(ptrint_t)tag);
assert(v != HT_NOTFOUND);
return v;
}
if (tag == BackRef_tag || tag == ShortBackRef_tag) {
assert(tree_literal_values == NULL);
ptrint_t offs = (tag == BackRef_tag) ? read_int32(s) : read_uint16(s);
void **bp = ptrhash_bp(&backref_table, (void*)(ptrint_t)offs);
assert(*bp != HT_NOTFOUND);
return (jl_value_t*)*bp;
}
jl_value_t *vtag=(jl_value_t*)ptrhash_get(&deser_tag,(void*)(ptrint_t)tag);
if (tag >= VALUE_TAGS) {
return vtag;
}
int usetable = (tree_literal_values == NULL);
size_t i;
if (vtag == (jl_value_t*)jl_tuple_type ||
vtag == (jl_value_t*)LongTuple_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_tuple_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_tuple_t *tu = jl_alloc_tuple_uninit(len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)tu);
for(i=0; i < len; i++)
jl_tupleset(tu, i, jl_deserialize_value(s));
return (jl_value_t*)tu;
}
else if (vtag == (jl_value_t*)jl_symbol_type ||
vtag == (jl_value_t*)LongSymbol_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_symbol_type)
len = read_uint8(s);
else
len = read_int32(s);
char *name = alloca(len+1);
ios_read(s, name, len);
name[len] = '\0';
jl_value_t *s = (jl_value_t*)jl_symbol(name);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, s);
return s;
}
else if (vtag == (jl_value_t*)jl_array_type) {
jl_value_t *aty = jl_deserialize_value(s);
jl_value_t *elty = jl_tparam0(aty);
int16_t ndims = jl_unbox_long(jl_tparam1(aty));
size_t *dims = alloca(ndims*sizeof(size_t));
for(i=0; i < ndims; i++)
dims[i] = jl_unbox_long(jl_deserialize_value(s));
jl_array_t *a = jl_new_array_((jl_type_t*)aty, ndims, dims);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)a);
if (jl_is_bits_type(elty)) {
size_t tot = jl_array_len(a) * a->elsize;
ios_read(s, jl_array_data(a), tot);
}
else {
for(i=0; i < jl_array_len(a); i++) {
((jl_value_t**)a->data)[i] = jl_deserialize_value(s);
}
}
return (jl_value_t*)a;
}
else if (vtag == (jl_value_t*)jl_expr_type ||
vtag == (jl_value_t*)LongExpr_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_expr_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s), len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)e);
e->etype = jl_deserialize_value(s);
for(i=0; i < len; i++) {
jl_cellset(e->args, i, jl_deserialize_value(s));
}
return (jl_value_t*)e;
}
else if (vtag == (jl_value_t*)LiteralVal_tag) {
return jl_cellref(tree_literal_values, read_uint16(s));
}
else if (vtag == (jl_value_t*)jl_tvar_type) {
jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_type_t*)jl_tvar_type, 4);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, tv);
tv->name = (jl_sym_t*)jl_deserialize_value(s);
tv->lb = jl_deserialize_value(s);
tv->ub = jl_deserialize_value(s);
tv->bound = read_int8(s);
return (jl_value_t*)tv;
}
else if (vtag == (jl_value_t*)jl_function_type) {
jl_function_t *f =
(jl_function_t*)newobj((jl_type_t*)jl_function_type, 3);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, f);
f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s);
f->env = jl_deserialize_value(s);
f->fptr = jl_deserialize_fptr(s);
return (jl_value_t*)f;
}
else if (vtag == (jl_value_t*)jl_lambda_info_type) {
jl_lambda_info_t *li =
(jl_lambda_info_t*)newobj((jl_type_t*)jl_lambda_info_type,
LAMBDA_INFO_NW);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, li);
li->ast = jl_deserialize_value(s);
li->sparams = (jl_tuple_t*)jl_deserialize_value(s);
li->tfunc = jl_deserialize_value(s);
li->name = (jl_sym_t*)jl_deserialize_value(s);
li->specTypes = (jl_tuple_t*)jl_deserialize_value(s);
li->specializations = (jl_array_t*)jl_deserialize_value(s);
li->inferred = read_int8(s);
li->file = jl_deserialize_value(s);
li->line = read_int32(s);
li->module = (jl_module_t*)jl_deserialize_value(s);
li->roots = (jl_array_t*)jl_deserialize_value(s);
li->def = (jl_lambda_info_t*)jl_deserialize_value(s);
li->capt = jl_deserialize_value(s);
li->fptr = &jl_trampoline;
li->functionObject = NULL;
li->cFunctionObject = NULL;
li->inInference = 0;
li->inCompile = 0;
li->unspecialized = NULL;
return (jl_value_t*)li;
}
else if (vtag == (jl_value_t*)jl_module_type) {
jl_sym_t *mname = (jl_sym_t*)jl_deserialize_value(s);
jl_module_t *m = jl_new_module(mname);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, m);
m->parent = (jl_module_t*)jl_deserialize_value(s);
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_binding_t *b = jl_get_binding_wr(m, (jl_sym_t*)name);
b->value = jl_deserialize_value(s);
b->type = (jl_type_t*)jl_deserialize_value(s);
b->owner = (jl_module_t*)jl_deserialize_value(s);
int8_t flags = read_int8(s);
b->constp = (flags>>2) & 1;
b->exportp = (flags>>1) & 1;
b->imported = (flags) & 1;
}
size_t ni = read_int32(s);
for(size_t i=0; i < ni; i++) {
arraylist_push(&m->usings, jl_deserialize_value(s));
}
return (jl_value_t*)m;
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex, int *plineno)
{
assert(ex->head == module_sym);
jl_module_t *last_module = jl_current_module;
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 0);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *parent_module;
if (jl_current_module == jl_core_module ||
jl_current_module == jl_main_module) {
parent_module = jl_root_module;
}
else {
parent_module = jl_current_module;
}
jl_binding_t *b = jl_get_binding_wr(parent_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
JL_PRINTF(JL_STDERR, "Warning: replacing module %s\n", name->name);
}
jl_module_t *newm = jl_new_module(name);
newm->parent = (jl_value_t*)parent_module;
b->value = (jl_value_t*)newm;
if (parent_module == jl_root_module && name == jl_symbol("Base") &&
jl_base_module == NULL) {
// pick up Base module during bootstrap
jl_base_module = newm;
}
JL_GC_PUSH(&last_module);
jl_current_module = newm;
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 1))->args;
JL_TRY {
for(int i=0; i < exprs->length; i++) {
// process toplevel form
jl_value_t *form = jl_cellref(exprs, i);
if (jl_is_linenode(form)) {
if (plineno)
*plineno = jl_linenode_line(form);
}
else {
(void)jl_toplevel_eval_flex(form, 1, plineno);
}
}
}
JL_CATCH {
JL_GC_POP();
jl_current_module = last_module;
jl_raise(jl_exception_in_transit);
}
JL_GC_POP();
jl_current_module = last_module;
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (b->name->name[0]=='@' && !b->exportp)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
b->name->name, newm->name->name);
*/
}
}
return jl_nothing;
}
void julia_init(char *imageFile)
{
jl_page_size = jl_getpagesize();
jl_find_stack_bottom();
jl_dl_handle = jl_load_dynamic_library(NULL, JL_RTLD_DEFAULT);
#ifdef _OS_WINDOWS_
uv_dlopen("ntdll.dll",jl_ntdll_handle); //bypass julia's pathchecking for system dlls
uv_dlopen("Kernel32.dll",jl_kernel32_handle);
uv_dlopen("msvcrt.dll",jl_crtdll_handle);
uv_dlopen("Ws2_32.dll",jl_winsock_handle);
_jl_exe_handle.handle = GetModuleHandleA(NULL);
if (!DuplicateHandle( GetCurrentProcess(), GetCurrentThread(),
GetCurrentProcess(), (PHANDLE)&hMainThread, 0,
TRUE, DUPLICATE_SAME_ACCESS )) {
JL_PRINTF(JL_STDERR, "Couldn't access handle to main thread\n");
}
#if defined(_CPU_X86_64_)
SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
SymInitialize(GetCurrentProcess(), NULL, 1);
needsSymRefreshModuleList = 0;
#endif
#endif
jl_io_loop = uv_default_loop(); //this loop will internal events (spawining process etc.)
init_stdio();
#if defined(__linux__)
int ncores = jl_cpu_cores();
if (ncores > 1) {
cpu_set_t cpumask;
CPU_ZERO(&cpumask);
for(int i=0; i < ncores; i++) {
CPU_SET(i, &cpumask);
}
sched_setaffinity(0, sizeof(cpu_set_t), &cpumask);
}
#endif
#ifdef JL_GC_MARKSWEEP
jl_gc_init();
jl_gc_disable();
#endif
jl_init_frontend();
jl_init_types();
jl_init_tasks(jl_stack_lo, jl_stack_hi-jl_stack_lo);
jl_init_codegen();
jl_an_empty_cell = (jl_value_t*)jl_alloc_cell_1d(0);
jl_init_serializer();
if (!imageFile) {
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
jl_core_module = jl_new_module(jl_symbol("Core"));
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_module_using(jl_main_module, jl_core_module);
jl_current_module = jl_core_module;
jl_init_intrinsic_functions();
jl_init_primitives();
jl_load("boot.jl");
jl_get_builtin_hooks();
jl_boot_file_loaded = 1;
jl_init_box_caches();
}
if (imageFile) {
JL_TRY {
jl_restore_system_image(imageFile);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error during init:\n");
jl_show(jl_stderr_obj(), jl_exception_in_transit);
JL_PRINTF(JL_STDERR, "\n");
jl_exit(1);
}
}
// set module field of primitive types
int i;
void **table = jl_core_module->bindings.table;
for(i=1; i < jl_core_module->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
if (b->value && jl_is_datatype(b->value)) {
jl_datatype_t *tt = (jl_datatype_t*)b->value;
tt->name->module = jl_core_module;
}
}
}
// the Main module is the one which is always open, and set as the
// current module for bare (non-module-wrapped) toplevel expressions.
// it does "using Base" if Base is available.
if (jl_base_module != NULL) {
jl_add_standard_imports(jl_main_module);
}
// eval() uses Main by default, so Main.eval === Core.eval
jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
jl_current_module = jl_main_module;
#ifndef _OS_WINDOWS_
signal_stack = malloc(SIGSTKSZ);
struct sigaction actf;
memset(&actf, 0, sizeof(struct sigaction));
sigemptyset(&actf.sa_mask);
actf.sa_handler = fpe_handler;
actf.sa_flags = 0;
if (sigaction(SIGFPE, &actf, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
#if defined(_OS_LINUX_)
stack_t ss;
ss.ss_flags = 0;
ss.ss_size = SIGSTKSZ;
ss.ss_sp = signal_stack;
if (sigaltstack(&ss, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaltstack: %s\n", strerror(errno));
jl_exit(1);
}
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = segv_handler;
act.sa_flags = SA_ONSTACK | SA_SIGINFO;
if (sigaction(SIGSEGV, &act, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
if (signal(SIGPIPE,SIG_IGN) == SIG_ERR) {
JL_PRINTF(JL_STDERR, "Couldn't set SIGPIPE\n");
jl_exit(1);
}
#elif defined (_OS_DARWIN_)
kern_return_t ret;
mach_port_t self = mach_task_self();
ret = mach_port_allocate(self,MACH_PORT_RIGHT_RECEIVE,&segv_port);
HANDLE_MACH_ERROR("mach_port_allocate",ret);
ret = mach_port_insert_right(self,segv_port,segv_port,MACH_MSG_TYPE_MAKE_SEND);
HANDLE_MACH_ERROR("mach_port_insert_right",ret);
// Alright, create a thread to serve as the listener for exceptions
pthread_t thread;
pthread_attr_t attr;
if (pthread_attr_init(&attr) != 0)
{
JL_PRINTF(JL_STDERR, "pthread_attr_init failed");
jl_exit(1);
}
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
if (pthread_create(&thread,&attr,mach_segv_listener,NULL) != 0)
{
JL_PRINTF(JL_STDERR, "pthread_create failed");
jl_exit(1);
}
pthread_attr_destroy(&attr);
ret = task_set_exception_ports(self,EXC_MASK_BAD_ACCESS,segv_port,EXCEPTION_DEFAULT,MACHINE_THREAD_STATE);
HANDLE_MACH_ERROR("task_set_exception_ports",ret);
#endif
#else
if (signal(SIGFPE, (void (__cdecl *)(int))fpe_handler) == SIG_ERR) {
JL_PRINTF(JL_STDERR, "Couldn't set SIGFPE\n");
jl_exit(1);
}
#endif
#ifdef JL_GC_MARKSWEEP
jl_gc_enable();
#endif
}
void julia_init(char *imageFile)
{
jl_page_size = sysconf(_SC_PAGESIZE);
jl_find_stack_bottom();
jl_dl_handle = jl_load_dynamic_library(NULL);
#ifdef JL_GC_MARKSWEEP
jl_gc_init();
jl_gc_disable();
#endif
jl_init_frontend();
jl_init_types();
jl_init_tasks(jl_stack_lo, jl_stack_hi-jl_stack_lo);
jl_init_codegen();
jl_an_empty_cell = (jl_value_t*)jl_alloc_cell_1d(0);
jl_init_serializer();
if (!imageFile) {
jl_core_module = jl_new_module(jl_symbol("Core"));
jl_current_module = jl_core_module;
jl_init_intrinsic_functions();
jl_init_primitives();
jl_load("src/boot.jl");
jl_get_builtin_hooks();
jl_boot_file_loaded = 1;
jl_init_box_caches();
}
if (imageFile) {
JL_TRY {
jl_restore_system_image(imageFile);
}
JL_CATCH {
ios_printf(ios_stderr, "error during init:\n");
jl_show(jl_exception_in_transit);
ios_printf(ios_stdout, "\n");
exit(1);
}
}
struct sigaction actf;
memset(&actf, 0, sizeof(struct sigaction));
sigemptyset(&actf.sa_mask);
actf.sa_handler = fpe_handler;
actf.sa_flags = 0;
if (sigaction(SIGFPE, &actf, NULL) < 0) {
ios_printf(ios_stderr, "sigaction: %s\n", strerror(errno));
exit(1);
}
stack_t ss;
ss.ss_flags = 0;
ss.ss_size = SIGSTKSZ;
ss.ss_sp = malloc(ss.ss_size);
if (sigaltstack(&ss, NULL) < 0) {
ios_printf(ios_stderr, "sigaltstack: %s\n", strerror(errno));
exit(1);
}
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = segv_handler;
act.sa_flags = SA_ONSTACK | SA_SIGINFO;
if (sigaction(SIGSEGV, &act, NULL) < 0) {
ios_printf(ios_stderr, "sigaction: %s\n", strerror(errno));
exit(1);
}
#ifdef JL_GC_MARKSWEEP
jl_gc_enable();
#endif
}
void julia_init(char *imageFile)
{
(void)uv_default_loop();
restore_signals(); //XXX: this needs to be early in load process
jl_page_size = sysconf(_SC_PAGESIZE);
jl_find_stack_bottom();
jl_dl_handle = jl_load_dynamic_library(NULL);
#if defined(__linux__)
int ncores = jl_cpu_cores();
if (ncores > 1) {
cpu_set_t cpumask;
CPU_ZERO(&cpumask);
for(int i=0; i < ncores; i++) {
CPU_SET(i, &cpumask);
}
sched_setaffinity(0, sizeof(cpu_set_t), &cpumask);
}
#endif
#ifdef JL_GC_MARKSWEEP
jl_gc_init();
jl_gc_disable();
#endif
jl_init_frontend();
jl_init_types();
jl_init_tasks(jl_stack_lo, jl_stack_hi-jl_stack_lo);
jl_init_codegen();
jl_an_empty_cell = (jl_value_t*)jl_alloc_cell_1d(0);
jl_init_serializer();
if (!imageFile) {
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
jl_core_module = jl_new_module(jl_symbol("Core"));
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_module_using(jl_main_module, jl_core_module);
jl_current_module = jl_core_module;
jl_init_intrinsic_functions();
jl_init_primitives();
jl_load("boot.jl");
jl_get_builtin_hooks();
jl_boot_file_loaded = 1;
jl_init_box_caches();
}
if (imageFile) {
JL_TRY {
jl_restore_system_image(imageFile);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error during init:\n");
jl_show(jl_stderr_obj(), jl_exception_in_transit);
JL_PRINTF(JL_STDOUT, "\n");
jl_exit(1);
}
}
// set module field of primitive types
int i;
void **table = jl_core_module->bindings.table;
for(i=1; i < jl_core_module->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
if (b->value && jl_is_some_tag_type(b->value)) {
jl_tag_type_t *tt = (jl_tag_type_t*)b->value;
tt->name->module = jl_core_module;
}
}
}
// the Main module is the one which is always open, and set as the
// current module for bare (non-module-wrapped) toplevel expressions.
// it does "using Base" if Base is available.
if (jl_base_module != NULL)
jl_module_using(jl_main_module, jl_base_module);
jl_current_module = jl_main_module;
#ifndef __WIN32__
struct sigaction actf;
memset(&actf, 0, sizeof(struct sigaction));
sigemptyset(&actf.sa_mask);
actf.sa_handler = fpe_handler;
actf.sa_flags = 0;
if (sigaction(SIGFPE, &actf, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
stack_t ss;
ss.ss_flags = 0;
ss.ss_size = SIGSTKSZ;
ss.ss_sp = malloc(ss.ss_size);
if (sigaltstack(&ss, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaltstack: %s\n", strerror(errno));
jl_exit(1);
}
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = segv_handler;
act.sa_flags = SA_ONSTACK | SA_SIGINFO;
if (sigaction(SIGSEGV, &act, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
#endif
atexit(jl_atexit_hook);
#ifdef JL_GC_MARKSWEEP
jl_gc_enable();
#endif
}
void jl_init_modules(void)
{
jl_system_module = jl_new_module(jl_symbol("System"));
jl_user_module = jl_new_module(jl_symbol("User"));
varlist_binding = jl_get_binding(jl_system_module, jl_symbol("VARIABLES"));
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
{
assert(ex->head == module_sym);
jl_module_t *last_module = jl_current_module;
int std_imports = (jl_exprarg(ex,0)==jl_true);
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 1);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *parent_module = jl_current_module;
jl_binding_t *b = jl_get_binding_wr(parent_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
JL_PRINTF(JL_STDERR, "Warning: replacing module %s\n", name->name);
}
jl_module_t *newm = jl_new_module(name);
newm->parent = parent_module;
b->value = (jl_value_t*)newm;
if (parent_module == jl_main_module && name == jl_symbol("Base")) {
jl_old_base_module = jl_base_module;
// pick up Base module during bootstrap
jl_base_module = newm;
}
// export all modules from Main
if (parent_module == jl_main_module)
jl_module_export(jl_main_module, name);
// add standard imports unless baremodule
if (std_imports) {
if (jl_base_module != NULL)
jl_module_using(newm, jl_base_module); // using Base
}
JL_GC_PUSH(&last_module);
jl_current_module = newm;
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
JL_TRY {
for(int i=0; i < exprs->length; i++) {
// process toplevel form
jl_value_t *form = jl_cellref(exprs, i);
(void)jl_toplevel_eval_flex(form, 1);
}
}
JL_CATCH {
jl_current_module = last_module;
jl_rethrow();
}
JL_GC_POP();
jl_current_module = last_module;
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (b->name->name[0]=='@' && !b->exportp)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
b->name->name, newm->name->name);
*/
}
}
return jl_nothing;
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
{
jl_ptls_t ptls = jl_get_ptls_states();
static arraylist_t module_stack;
static int initialized=0;
static jl_module_t *outermost = NULL;
if (!initialized) {
arraylist_new(&module_stack, 0);
initialized = 1;
}
assert(ex->head == module_sym);
jl_module_t *last_module = ptls->current_module;
if (jl_array_len(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex,2))) {
jl_error("syntax: malformed module expression");
}
int std_imports = (jl_exprarg(ex,0)==jl_true);
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 1);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *parent_module = ptls->current_module;
jl_binding_t *b = jl_get_binding_wr(parent_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
if (!jl_is_module(b->value)) {
jl_errorf("invalid redefinition of constant %s",
jl_symbol_name(name));
}
if (jl_generating_output()) {
jl_errorf("cannot replace module %s during compilation",
jl_symbol_name(name));
}
jl_printf(JL_STDERR, "WARNING: replacing module %s\n",
jl_symbol_name(name));
}
jl_module_t *newm = jl_new_module(name);
newm->parent = parent_module;
b->value = (jl_value_t*)newm;
jl_gc_wb_binding(b, newm);
if (parent_module == jl_main_module && name == jl_symbol("Base")) {
// pick up Base module during bootstrap
jl_base_module = newm;
}
// export all modules from Main
if (parent_module == jl_main_module)
jl_module_export(jl_main_module, name);
// add standard imports unless baremodule
if (std_imports) {
if (jl_base_module != NULL) {
jl_add_standard_imports(newm);
}
}
jl_value_t *defaultdefs = NULL, *form = NULL;
JL_GC_PUSH3(&last_module, &defaultdefs, &form);
jl_module_t *task_last_m = ptls->current_task->current_module;
ptls->current_task->current_module = ptls->current_module = newm;
jl_module_t *prev_outermost = outermost;
size_t stackidx = module_stack.len;
if (outermost == NULL)
outermost = newm;
if (std_imports) {
// add `eval` function
defaultdefs = jl_call_scm_on_ast("module-default-defs", (jl_value_t*)ex);
jl_toplevel_eval_flex(defaultdefs, 0, 1);
defaultdefs = NULL;
}
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
JL_TRY {
for(int i=0; i < jl_array_len(exprs); i++) {
// process toplevel form
form = jl_expand(jl_array_ptr_ref(exprs, i));
(void)jl_toplevel_eval_flex(form, 1, 1);
}
}
JL_CATCH {
ptls->current_module = last_module;
ptls->current_task->current_module = task_last_m;
outermost = prev_outermost;
module_stack.len = stackidx;
jl_rethrow();
}
JL_GC_POP();
ptls->current_module = last_module;
ptls->current_task->current_module = task_last_m;
outermost = prev_outermost;
#if 0
// some optional post-processing steps
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (jl_symbol_name(b->name)[0]=='@' &&
!b->exportp && b->owner == newm)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
jl_symbol_name(b->name), jl_symbol_name(newm->name));
*/
}
}
#endif
arraylist_push(&module_stack, newm);
if (outermost == NULL || ptls->current_module == jl_main_module) {
JL_TRY {
size_t i, l=module_stack.len;
for(i = stackidx; i < l; i++) {
jl_module_load_time_initialize((jl_module_t*)module_stack.items[i]);
}
assert(module_stack.len == l);
module_stack.len = stackidx;
}
JL_CATCH {
module_stack.len = stackidx;
jl_rethrow();
}
}
jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
{
static arraylist_t module_stack;
static int initialized=0;
if (!initialized) {
arraylist_new(&module_stack, 0);
initialized = 1;
}
assert(ex->head == module_sym);
jl_module_t *last_module = jl_current_module;
if (jl_array_len(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex,2))) {
jl_error("syntax: malformed module expression");
}
int std_imports = (jl_exprarg(ex,0)==jl_true);
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 1);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *parent_module = jl_current_module;
jl_binding_t *b = jl_get_binding_wr(parent_module, name);
jl_declare_constant(b);
if (b->value != NULL) {
JL_PRINTF(JL_STDERR, "Warning: replacing module %s\n", name->name);
}
jl_module_t *newm = jl_new_module(name);
newm->parent = parent_module;
b->value = (jl_value_t*)newm;
if (parent_module == jl_main_module && name == jl_symbol("Base")) {
// pick up Base module during bootstrap
jl_old_base_module = jl_base_module;
jl_base_module = newm;
// reinitialize global variables
// to pick up new types from Base
jl_errorexception_type = NULL;
jl_typeerror_type = NULL;
jl_methoderror_type = NULL;
jl_loaderror_type = NULL;
jl_weakref_type = NULL;
jl_current_task->tls = jl_nothing;
}
// export all modules from Main
if (parent_module == jl_main_module)
jl_module_export(jl_main_module, name);
// add standard imports unless baremodule
if (std_imports) {
if (jl_base_module != NULL) {
jl_add_standard_imports(newm);
}
}
JL_GC_PUSH1(&last_module);
jl_module_t *task_last_m = jl_current_task->current_module;
jl_current_task->current_module = jl_current_module = newm;
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
JL_TRY {
for(int i=0; i < jl_array_len(exprs); i++) {
// process toplevel form
jl_value_t *form = jl_cellref(exprs, i);
(void)jl_toplevel_eval_flex(form, 1);
}
}
JL_CATCH {
jl_current_module = last_module;
jl_current_task->current_module = task_last_m;
jl_rethrow();
}
JL_GC_POP();
jl_current_module = last_module;
jl_current_task->current_module = task_last_m;
#if 0
// some optional post-processing steps
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (b->name->name[0]=='@' && !b->exportp && b->owner==newm)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
b->name->name, newm->name->name);
*/
}
}
#endif
arraylist_push(&module_stack, newm);
if (jl_current_module == jl_main_module) {
while (module_stack.len > 0) {
jl_module_load_time_initialize((jl_module_t *) arraylist_pop(&module_stack));
}
}
return jl_nothing;
}
void julia_init(char *imageFile)
{
jl_page_size = jl_getpagesize();
jl_find_stack_bottom();
jl_dl_handle = jl_load_dynamic_library(NULL, JL_RTLD_DEFAULT);
#ifdef __WIN32__
uv_dlopen("ntdll.dll",jl_ntdll_handle); //bypass julia's pathchecking for system dlls
uv_dlopen("Kernel32.dll",jl_kernel32_handle);
uv_dlopen("msvcrt.dll",jl_crtdll_handle);
uv_dlopen("Ws2_32.dll",jl_winsock_handle);
_jl_exe_handle.handle = GetModuleHandleA(NULL);
#endif
jl_io_loop = uv_default_loop(); //this loop will internal events (spawining process etc.)
init_stdio();
#if defined(__linux__)
int ncores = jl_cpu_cores();
if (ncores > 1) {
cpu_set_t cpumask;
CPU_ZERO(&cpumask);
for(int i=0; i < ncores; i++) {
CPU_SET(i, &cpumask);
}
sched_setaffinity(0, sizeof(cpu_set_t), &cpumask);
}
#endif
#ifdef JL_GC_MARKSWEEP
jl_gc_init();
jl_gc_disable();
#endif
jl_init_frontend();
jl_init_types();
jl_init_tasks(jl_stack_lo, jl_stack_hi-jl_stack_lo);
jl_init_codegen();
jl_an_empty_cell = (jl_value_t*)jl_alloc_cell_1d(0);
jl_init_serializer();
if (!imageFile) {
jl_main_module = jl_new_module(jl_symbol("Main"));
jl_main_module->parent = jl_main_module;
jl_core_module = jl_new_module(jl_symbol("Core"));
jl_core_module->parent = jl_main_module;
jl_set_const(jl_main_module, jl_symbol("Core"),
(jl_value_t*)jl_core_module);
jl_module_using(jl_main_module, jl_core_module);
jl_current_module = jl_core_module;
jl_init_intrinsic_functions();
jl_init_primitives();
jl_load("boot.jl");
jl_get_builtin_hooks();
jl_boot_file_loaded = 1;
jl_init_box_caches();
}
if (imageFile) {
JL_TRY {
jl_restore_system_image(imageFile);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error during init:\n");
jl_show(jl_stderr_obj(), jl_exception_in_transit);
JL_PRINTF(JL_STDOUT, "\n");
jl_exit(1);
}
}
// set module field of primitive types
int i;
void **table = jl_core_module->bindings.table;
for(i=1; i < jl_core_module->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
if (b->value && jl_is_datatype(b->value)) {
jl_datatype_t *tt = (jl_datatype_t*)b->value;
tt->name->module = jl_core_module;
}
}
}
// the Main module is the one which is always open, and set as the
// current module for bare (non-module-wrapped) toplevel expressions.
// it does "using Base" if Base is available.
if (jl_base_module != NULL) {
jl_add_standard_imports(jl_main_module);
}
// eval() uses Main by default, so Main.eval === Core.eval
jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
jl_current_module = jl_main_module;
#ifndef __WIN32__
struct sigaction actf;
memset(&actf, 0, sizeof(struct sigaction));
sigemptyset(&actf.sa_mask);
actf.sa_handler = fpe_handler;
actf.sa_flags = 0;
if (sigaction(SIGFPE, &actf, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
stack_t ss;
ss.ss_flags = 0;
ss.ss_size = SIGSTKSZ;
ss.ss_sp = malloc(ss.ss_size);
if (sigaltstack(&ss, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaltstack: %s\n", strerror(errno));
jl_exit(1);
}
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = segv_handler;
act.sa_flags = SA_ONSTACK | SA_SIGINFO;
if (sigaction(SIGSEGV, &act, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
#else
if (signal(SIGFPE, (void (__cdecl *)(int))fpe_handler) == SIG_ERR) {
JL_PRINTF(JL_STDERR, "Couldn't set SIGFPE\n");
jl_exit(1);
}
#endif
#ifdef JL_GC_MARKSWEEP
jl_gc_enable();
#endif
}
// TODO: add locks around global state mutation operations
jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex)
{
jl_ptls_t ptls = jl_get_ptls_states();
assert(ex->head == module_sym);
if (jl_array_len(ex->args) != 3 || !jl_is_expr(jl_exprarg(ex, 2))) {
jl_error("syntax: malformed module expression");
}
int std_imports = (jl_exprarg(ex, 0) == jl_true);
jl_sym_t *name = (jl_sym_t*)jl_exprarg(ex, 1);
if (!jl_is_symbol(name)) {
jl_type_error("module", (jl_value_t*)jl_sym_type, (jl_value_t*)name);
}
jl_module_t *newm = jl_new_module(name);
jl_value_t *form = (jl_value_t*)newm;
JL_GC_PUSH1(&form);
ptrhash_put(&jl_current_modules, (void*)newm, (void*)((uintptr_t)HT_NOTFOUND + 1));
// copy parent environment info into submodule
newm->uuid = parent_module->uuid;
if (jl_base_module &&
(jl_value_t*)parent_module == jl_get_global(jl_base_module, jl_symbol("__toplevel__"))) {
newm->parent = newm;
jl_register_root_module(newm);
}
else {
jl_binding_t *b = jl_get_binding_wr(parent_module, name, 1);
jl_declare_constant(b);
if (b->value != NULL) {
if (!jl_is_module(b->value)) {
jl_errorf("invalid redefinition of constant %s", jl_symbol_name(name));
}
if (jl_generating_output()) {
jl_errorf("cannot replace module %s during compilation", jl_symbol_name(name));
}
jl_printf(JL_STDERR, "WARNING: replacing module %s.\n", jl_symbol_name(name));
// create a hidden gc root for the old module
uintptr_t *refcnt = (uintptr_t*)ptrhash_bp(&jl_current_modules, (void*)b->value);
*refcnt += 1;
}
newm->parent = parent_module;
b->value = (jl_value_t*)newm;
jl_gc_wb_binding(b, newm);
}
if (parent_module == jl_main_module && name == jl_symbol("Base")) {
// pick up Base module during bootstrap
jl_base_module = newm;
}
size_t last_age = ptls->world_age;
// add standard imports unless baremodule
if (std_imports) {
if (jl_base_module != NULL) {
jl_add_standard_imports(newm);
}
// add `eval` function
form = jl_call_scm_on_ast("module-default-defs", (jl_value_t*)ex, newm);
ptls->world_age = jl_world_counter;
jl_toplevel_eval_flex(newm, form, 0, 1);
form = NULL;
}
jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
for (int i = 0; i < jl_array_len(exprs); i++) {
// process toplevel form
ptls->world_age = jl_world_counter;
form = jl_expand_stmt(jl_array_ptr_ref(exprs, i), newm);
ptls->world_age = jl_world_counter;
(void)jl_toplevel_eval_flex(newm, form, 1, 1);
}
ptls->world_age = last_age;
#if 0
// some optional post-processing steps
size_t i;
void **table = newm->bindings.table;
for(i=1; i < newm->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
// remove non-exported macros
if (jl_symbol_name(b->name)[0]=='@' &&
!b->exportp && b->owner == newm)
b->value = NULL;
// error for unassigned exports
/*
if (b->exportp && b->owner==newm && b->value==NULL)
jl_errorf("identifier %s exported from %s is not initialized",
jl_symbol_name(b->name), jl_symbol_name(newm->name));
*/
}
}
#endif
uintptr_t *refcnt = (uintptr_t*)ptrhash_bp(&jl_current_modules, (void*)newm);
assert(*refcnt > (uintptr_t)HT_NOTFOUND);
*refcnt -= 1;
// newm should be reachable from somewhere else by now
if (jl_module_init_order == NULL)
jl_module_init_order = jl_alloc_vec_any(0);
jl_array_ptr_1d_push(jl_module_init_order, (jl_value_t*)newm);
// defer init of children until parent is done being defined
// then initialize all in definition-finished order
// at build time, don't run them at all (defer for runtime)
if (!jl_generating_output()) {
if (!ptrhash_has(&jl_current_modules, (void*)newm->parent)) {
size_t i, l = jl_array_len(jl_module_init_order);
size_t ns = 0;
form = (jl_value_t*)jl_alloc_vec_any(0);
for (i = 0; i < l; i++) {
jl_module_t *m = (jl_module_t*)jl_array_ptr_ref(jl_module_init_order, i);
if (jl_is_submodule(m, newm)) {
jl_array_ptr_1d_push((jl_array_t*)form, (jl_value_t*)m);
}
else if (ns++ != i) {
jl_array_ptr_set(jl_module_init_order, ns - 1, (jl_value_t*)m);
}
}
if (ns < l)
jl_array_del_end(jl_module_init_order, l - ns);
l = jl_array_len(form);
for (i = 0; i < l; i++) {
jl_module_t *m = (jl_module_t*)jl_array_ptr_ref(form, i);
JL_GC_PROMISE_ROOTED(m);
jl_module_run_initializer(m);
}
}
}
JL_GC_POP();
return (jl_value_t*)newm;
}
