JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_ptls_t ptls = jl_get_ptls_states();
jl_module_t *m = (jl_module_t*)jl_gc_alloc(ptls, sizeof(jl_module_t),
jl_module_type);
JL_GC_PUSH1(&m);
assert(jl_is_symbol(name));
m->name = name;
m->parent = NULL;
m->istopmod = 0;
static unsigned int mcounter; // simple counter backup, in case hrtime is not incrementing
m->uuid = jl_hrtime() + (++mcounter);
if (!m->uuid) m->uuid++; // uuid 0 is invalid
m->counter = 0;
htable_new(&m->bindings, 0);
arraylist_new(&m->usings, 0);
if (jl_core_module) {
jl_module_using(m, jl_core_module);
}
// export own name, so "using Foo" makes "Foo" itself visible
jl_set_const(m, name, (jl_value_t*)m);
jl_module_export(m, name);
JL_GC_POP();
return m;
}
int true_main(int argc, char *argv[])
{
if (jl_base_module != NULL) {
jl_array_t *args = jl_alloc_cell_1d(argc);
jl_set_global(jl_base_module, jl_symbol("ARGS"), (jl_value_t*)args);
int i;
for (i=0; i < argc; i++) {
jl_arrayset(args, (jl_value_t*)jl_cstr_to_string(argv[i]), i);
}
}
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
// run program if specified, otherwise enter REPL
if (program) {
return exec_program();
}
init_repl_environment(argc, argv);
jl_function_t *start_client =
(jl_function_t*)jl_get_global(jl_base_module, jl_symbol("_start"));
if (start_client) {
jl_apply(start_client, NULL, 0);
return 0;
}
// client event loop not available; use fallback blocking version
int iserr = 0;
again:
;
JL_TRY {
if (iserr) {
jl_show(jl_stderr_obj(), jl_exception_in_transit);
ios_printf(ios_stderr, "\n\n");
iserr = 0;
}
while (1) {
char *input = read_expr("julia> ");
if (!input || ios_eof(ios_stdin)) {
ios_printf(ios_stdout, "\n");
break;
}
jl_value_t *ast = jl_parse_input_line(input);
jl_value_t *value = jl_toplevel_eval(ast);
jl_show(jl_stdout_obj(), value);
ios_printf(ios_stdout, "\n\n");
}
}
JL_CATCH {
iserr = 1;
goto again;
}
return 0;
}
// argument is the usr/lib directory where libjulia is, or NULL to guess.
// if that doesn't work, try the full path to the "lib" directory that
// contains lib/julia/sys.ji
DLLEXPORT void jl_init(char *julia_home_dir)
{
libsupport_init();
char *image_file = jl_locate_sysimg(julia_home_dir);
julia_init(image_file);
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
}
// argument is the usr/lib directory where libjulia is, or NULL to guess.
// if that doesn't work, try the full path to the "lib" directory that
// contains lib/julia/sys.ji
DLLEXPORT void jl_init(char *julia_home_dir)
{
libsupport_init();
char *image_file = jl_locate_sysimg(julia_home_dir);
julia_init(image_file);
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
jl_eval_string("Base.reinit_stdio()");
jl_eval_string("Base.librandom_init()");
jl_eval_string("Base.init_sched()");
jl_eval_string("Base.init_head_sched()");
jl_eval_string("Base.init_load_path()");
}
// argument is the usr/lib directory where libjulia is, or NULL to guess.
// if that doesn't work, try the full path to the "lib" directory that
// contains lib/julia/sys.ji
DLLEXPORT void jl_init(char *julia_home_dir)
{
if (jl_is_initialized()) return;
libsupport_init();
char *image_file = jl_locate_sysimg(julia_home_dir, JL_SYSTEM_IMAGE_PATH);
julia_init(image_file);
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
jl_eval_string("Base.reinit_stdio()");
jl_eval_string("Base.Random.librandom_init()");
jl_eval_string("Base.init_sched()");
jl_eval_string("Base.init_head_sched()");
jl_eval_string("Base.init_load_path()");
}
jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_module_t *m = (jl_module_t*)allocobj(sizeof(jl_module_t));
m->type = (jl_value_t*)jl_module_type;
m->name = name;
htable_new(&m->bindings, 0);
jl_set_const(m, name, (jl_value_t*)m);
arraylist_new(&m->usings, 0);
if (jl_core_module) {
jl_module_using(m, jl_core_module);
}
// export own name, so "using Foo" makes "Foo" itself visible
jl_module_export(m, name);
return m;
}
// First argument is the usr/lib directory where libjulia is, or NULL to guess.
// if that doesn't work, try the full path to the "lib" directory that
// contains lib/julia/sys.ji
// Second argument is the path of a system image file (*.ji) relative to the
// first argument path, or relative to the default julia home dir. The default
// is something like ../lib/julia/sys.ji
DLLEXPORT void jl_init_with_image(char *julia_home_dir, char *image_relative_path)
{
if (jl_is_initialized()) return;
libsupport_init();
if (image_relative_path == NULL)
image_relative_path = JL_SYSTEM_IMAGE_PATH;
char *image_file = jl_locate_sysimg(julia_home_dir, image_relative_path);
julia_init(image_file);
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
jl_eval_string("Base.early_init()");
jl_eval_string("Base.init_head_sched()");
jl_eval_string("Base.init_load_path()");
jl_exception_clear();
}
JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_module_t *m = (jl_module_t*)jl_gc_allocobj(sizeof(jl_module_t));
jl_set_typeof(m, jl_module_type);
JL_GC_PUSH1(&m);
assert(jl_is_symbol(name));
m->name = name;
m->parent = NULL;
m->istopmod = 0;
m->uuid = uv_now(uv_default_loop());
m->counter = 0;
htable_new(&m->bindings, 0);
arraylist_new(&m->usings, 0);
if (jl_core_module) {
jl_module_using(m, jl_core_module);
}
// export own name, so "using Foo" makes "Foo" itself visible
jl_set_const(m, name, (jl_value_t*)m);
jl_module_export(m, name);
JL_GC_POP();
return m;
}
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_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)
{
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;
}
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_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;
}
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();
}
}
//-| mode=="rcqls" is for rcqls development, mode="tty" is for initialization of STDOUT, STDERR with C API)
//-| other value of mode mean standard jlapi.c
DLLEXPORT void jlapi_init(char *julia_home_dir, char* mode) {
libsupport_init();
char *image_file = jl_locate_sysimg(julia_home_dir);
printf("image-file=%s\n",image_file);
julia_init(image_file);
jlapi_mode=mode;
jl_set_const(jl_core_module, jl_symbol("JULIA_HOME"),
jl_cstr_to_string(julia_home));
jl_module_export(jl_core_module, jl_symbol("JULIA_HOME"));
//-| This avoid LD_PRELOAD on linux since shared objects not exported
//-| Maybe fix this in a better way with options compilation.
char julia_api_libname[512];
#if defined(_OS_WINDOWS_)
const char *shlib_ext=".dll";
const char *sep="\\";
#elif defined(__APPLE__)
const char *shlib_ext=".dylib";
const char *sep="/";
#else
const char *shlib_ext=".so";
const char *sep="/";
#endif
snprintf(julia_api_libname, sizeof(julia_api_libname), "%s%s%s%s%s%s",
julia_home_dir, sep,"julia",sep,"libjulia-api",shlib_ext);
load_library_permanently(julia_api_libname);
if(strcmp(mode,"rcqls")<=0) { // cqls, rcqls
//-| Called first to fix the DL_LOAD_PATH needed to (dl)open library (libpcre for example)
//-| Replacement of Base.init_load_path()
//-| Update 01/08/2013: No need to set DL_LOAD_PATH, just push
//-| jl_set_global(jl_base_module,jl_symbol("DL_LOAD_PATH"),jl_eval_string("ByteString[join([JULIA_HOME,\"..\",\"lib\",\"julia\"],Base.path_separator)]"));
jl_eval_string("Base.push!(DL_LOAD_PATH,join([JULIA_HOME,\"..\",\"lib\",\"julia\"],Base.path_separator))");
//-| DL_LOAD_PATH is a global constant already defined before and then not overloaded by julia
//-| Only LOAD_PATH would be initialized (needs libpcre because of abspath)!
jl_eval_string("vers = \"v$(VERSION.major).$(VERSION.minor)\"");
jl_set_global(jl_base_module,jl_symbol("LOAD_PATH"),jl_eval_string("ByteString[abspath(JULIA_HOME,\"..\",\"local\",\"share\",\"julia\",\"site\",vers),abspath(JULIA_HOME,\"..\",\"share\",\"julia\",\"site\",vers)]"));
} else jl_eval_string("Base.init_load_path()");
if(strcmp(mode,"tty")==0) {
jl_eval_string("Base.reinit_stdio()");
jl_set_global(jl_base_module,jl_symbol("STDIN"),jl_eval_string("Base.init_stdio(ccall(:jl_stdin_stream ,Ptr{Void},()),0)"));
//-| 2 next lines fails even it is if no more necessary
//-| Update 27/07/13: no more crash but stuck when print.
jl_set_global(jl_base_module,jl_symbol("STDOUT"),jl_eval_string("Base.init_stdio(ccall(:jl_stdout_stream,Ptr{Void},()),1)"));
jl_set_global(jl_base_module,jl_symbol("STDERR"),jl_eval_string("Base.init_stdio(ccall(:jl_stderr_stream,Ptr{Void},()),2)"));
} else if(strcmp(mode,"rcqls")<=0) { //cqls, rcqls
jl_eval_string("Base.reinit_stdio()");
//-| STDIN, STDOUT and STDERR not properly loaded
//-| I prefer redirection of STDOUT and STDERR in IOBuffer (maybe STDIN ???)
jl_set_global(jl_base_module,jl_symbol("STDIN"),jl_eval_string("Base.init_stdio(ccall(:jl_stdin_stream ,Ptr{Void},()),0)"));
//jl_set_global(jl_base_module,jl_symbol("STDIN"),jl_eval_string("IOBuffer()"));
jl_set_global(jl_base_module,jl_symbol("STDOUT"),jl_eval_string("IOBuffer()"));
jl_set_global(jl_base_module,jl_symbol("STDERR"),jl_eval_string("IOBuffer()"));
} else jl_eval_string("Base.reinit_stdio()");
jl_eval_string("Base.fdwatcher_reinit()");
jl_eval_string("Base.Random.librandom_init()");
jl_eval_string("Base.check_blas()");
jl_eval_string("LinAlg.init()");
jl_eval_string("Sys.init()");
jl_eval_string("Base.init_sched()");
jl_eval_string("Base.init_head_sched()");
jl_eval_string("Base.try_include(abspath(ENV[\"HOME\"],\".juliarc.jl\"))");
if(strcmp(mode,"rcqls")==0) {
jl_eval_string("println(\"Julia initialized!\")");
jlapi_print_stdout();
}
}
