void jl_gc_collect(void)
{
size_t actual_allocd = allocd_bytes;
total_allocd_bytes += allocd_bytes;
allocd_bytes = 0;
if (is_gc_enabled) {
JL_SIGATOMIC_BEGIN();
jl_in_gc = 1;
#if defined(GCTIME) || defined(GC_FINAL_STATS)
double t0 = clock_now();
#endif
gc_mark();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "mark time %.3f ms\n", (clock_now()-t0)*1000);
#endif
#if defined(MEMPROFILE)
all_pool_stats();
big_obj_stats();
#endif
#ifdef GCTIME
t0 = clock_now();
#endif
sweep_weak_refs();
gc_sweep();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "sweep time %.3f ms\n", (clock_now()-t0)*1000);
#endif
int nfinal = to_finalize.len;
run_finalizers();
jl_in_gc = 0;
JL_SIGATOMIC_END();
#if defined(GC_FINAL_STATS)
total_gc_time += (clock_now()-t0);
total_freed_bytes += freed_bytes;
#endif
#ifdef OBJPROFILE
print_obj_profile();
htable_reset(&obj_counts, 0);
#endif
// tune collect interval based on current live ratio
#if defined(MEMPROFILE)
jl_printf(JL_STDERR, "allocd %ld, freed %ld, interval %ld, ratio %.2f\n",
actual_allocd, freed_bytes, collect_interval,
(double)freed_bytes/(double)actual_allocd);
#endif
if (freed_bytes < (7*(actual_allocd/10))) {
if (collect_interval <= 2*(max_collect_interval/5))
collect_interval = 5*(collect_interval/2);
}
else {
collect_interval = default_collect_interval;
}
freed_bytes = 0;
// if a lot of objects were finalized, re-run GC to finish freeing
// their storage if possible.
if (nfinal > 100000)
jl_gc_collect();
}
}
void jl_gc_collect(void)
{
allocd_bytes = 0;
if (is_gc_enabled) {
JL_SIGATOMIC_BEGIN();
#ifdef GCTIME
double t0 = clock_now();
#endif
gc_mark();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "mark time %.3f ms\n", (clock_now()-t0)*1000);
#endif
#if defined(MEMPROFILE)
all_pool_stats();
big_obj_stats();
#endif
#ifdef GCTIME
t0 = clock_now();
#endif
sweep_weak_refs();
gc_sweep();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "sweep time %.3f ms\n", (clock_now()-t0)*1000);
#endif
run_finalizers();
JL_SIGATOMIC_END();
#ifdef OBJPROFILE
print_obj_profile();
htable_reset(&obj_counts, 0);
#endif
}
}
void jl_check_static_parameter_conflicts(jl_lambda_info_t *li, jl_tuple_t *t, jl_sym_t *fname)
{
jl_array_t *vinfo;
size_t nvars;
if (li->ast && jl_is_expr(li->ast)) {
vinfo = jl_lam_vinfo((jl_expr_t*)li->ast);
nvars = jl_array_len(vinfo);
for(size_t i=0; i < jl_tuple_len(t); i++) {
for(size_t j=0; j < nvars; j++) {
jl_value_t *tv = jl_tupleref(t,i);
if (jl_is_typevar(tv)) {
if ((jl_sym_t*)jl_arrayref((jl_array_t*)jl_arrayref(vinfo,j),0) ==
((jl_tvar_t*)tv)->name) {
JL_PRINTF(JL_STDERR,
"Warning: local variable %s conflicts with a static parameter in %s",
((jl_tvar_t*)tv)->name->name, fname->name);
print_func_loc(JL_STDERR, li);
JL_PRINTF(JL_STDERR, ".\n");
}
}
}
}
}
}
static void run_finalizer(jl_value_t *o, jl_value_t *ff)
{
jl_function_t *f;
while (jl_is_tuple(ff)) {
f = (jl_function_t*)jl_t0(ff);
assert(jl_is_function(f));
JL_TRY {
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error in running finalizer: ");
jl_static_show(JL_STDERR, jl_exception_in_transit);
JL_PUTC('\n',JL_STDERR);
}
ff = jl_t1(ff);
}
f = (jl_function_t*)ff;
assert(jl_is_function(f));
JL_TRY {
jl_apply(f, (jl_value_t**)&o, 1);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "error in running finalizer: ");
jl_static_show(JL_STDERR, jl_exception_in_transit);
JL_PUTC('\n',JL_STDERR);
}
}
DLLEXPORT void jl_(void *jl_value)
{
in_jl_++;
JL_TRY {
(void)jl_static_show(JL_STDOUT, (jl_value_t*)jl_value);
JL_PRINTF(JL_STDOUT,"\n");
}
JL_CATCH {
JL_PRINTF(JL_STDOUT, "\n!!! ERROR in jl_ -- ABORTING !!!\n");
}
in_jl_--;
}
virtual void NotifyFunctionEmitted(const Function &F, void *Code,
size_t Size, const EmittedFunctionDetails &Details)
{
#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
assert(!jl_in_stackwalk);
jl_in_stackwalk = 1;
uintptr_t catchjmp = (uintptr_t)Code+Size;
*(uint8_t*)(catchjmp+0) = 0x48;
*(uint8_t*)(catchjmp+1) = 0xb8; // mov RAX, QWORD PTR [...]
*(uint64_t*)(catchjmp+2) = (uint64_t)&_seh_exception_handler;
*(uint8_t*)(catchjmp+10) = 0xff;
*(uint8_t*)(catchjmp+11) = 0xe0; // jmp RAX
PRUNTIME_FUNCTION tbl = (PRUNTIME_FUNCTION)((catchjmp+12+3)&~(uintptr_t)3);
uint8_t *UnwindData = (uint8_t*)((((uintptr_t)&tbl[1])+3)&~(uintptr_t)3);
RUNTIME_FUNCTION fn = {0,(DWORD)Size+13,(DWORD)(intptr_t)(UnwindData-(uint8_t*)Code)};
tbl[0] = fn;
UnwindData[0] = 0x09; // version info, UNW_FLAG_EHANDLER
UnwindData[1] = 4; // size of prolog (bytes)
UnwindData[2] = 2; // count of unwind codes (slots)
UnwindData[3] = 0x05; // frame register (rbp) = rsp
UnwindData[4] = 4; // second instruction
UnwindData[5] = 0x03; // mov RBP, RSP
UnwindData[6] = 1; // first instruction
UnwindData[7] = 0x50; // push RBP
*(DWORD*)&UnwindData[8] = (DWORD)(catchjmp-(intptr_t)Code);
DWORD mod_size = (DWORD)(size_t)(&UnwindData[8]-(uint8_t*)Code);
if (!SymLoadModuleEx(GetCurrentProcess(), NULL, NULL, NULL, (DWORD64)Code, mod_size, NULL, SLMFLAG_VIRTUAL)) {
static int warned = 0;
if (!warned) {
JL_PRINTF(JL_STDERR, "WARNING: failed to insert function info for backtrace\n");
warned = 1;
}
}
else {
if (!SymAddSymbol(GetCurrentProcess(), (ULONG64)Code, F.getName().data(), (DWORD64)Code, mod_size, 0)) {
JL_PRINTF(JL_STDERR, "WARNING: failed to insert function name into debug info\n");
}
if (!RtlAddFunctionTable(tbl,1,(DWORD64)Code)) {
JL_PRINTF(JL_STDERR, "WARNING: failed to insert function stack unwind info\n");
}
}
jl_in_stackwalk = 0;
FuncInfo tmp = {&F, Size, std::string(), std::string(), tbl, Details.LineStarts};
#else
FuncInfo tmp = {&F, Size, std::string(F.getName().data()), std::string(), Details.LineStarts};
#endif
info[(size_t)(Code)] = tmp;
}
// comma_one prints a comma for 1 element, e.g. "(x,)"
static size_t jl_show_tuple(JL_STREAM *out, jl_tuple_t *t, char *opn, char *cls, int comma_one)
{
size_t i, n=0, len = jl_tuple_len(t);
n += JL_PRINTF(out, "(");
for (i = 0; i < len; i++) {
jl_value_t *v = jl_tupleref(t,i);
n += jl_static_show(out, v);
if (len == 1)
n += JL_PRINTF(out, ",");
else if (i != len-1)
n += JL_PRINTF(out, ", ");
}
n += JL_PRINTF(out, ")");
return n;
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
ios_t *s = (ios_t*)jl_iostr_data(str);
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "#<intrinsic-function %d>", *(uint32_t*)jl_bits_data(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
if (jl_is_struct_type(t)) {
jl_struct_type_t *st = (jl_struct_type_t*)t;
JL_PUTS(st->name->name->name, s);
JL_PUTC('(', s);
size_t i;
size_t n = jl_tuple_len(st->names);
for(i=0; i < n; i++) {
jl_show(str, nth_field(v, i));
if (i < n-1)
JL_PUTC(',', s);
}
JL_PUTC(')', s);
}
}
}
void jl_prep_terminal(int meta_flag)
{
FILE *rl_in = rl_instream;
rl_instream = stdin;
rl_prep_terminal(1);
rl_instream = rl_in;
#ifdef __WIN32__
if (jl_uv_stdin->type == UV_TTY) uv_tty_set_mode((uv_tty_t*)jl_uv_stdin,1); //raw (and libuv-processed)
if (!repl_sigint_handler_installed) {
if (SetConsoleCtrlHandler((PHANDLER_ROUTINE)repl_sigint_handler,1))
repl_sigint_handler_installed = 1;
}
#else
if (jl_sigint_act.sa_sigaction == NULL) {
struct sigaction oldact, repl_sigint_act;
memset(&repl_sigint_act, 0, sizeof(struct sigaction));
sigemptyset(&repl_sigint_act.sa_mask);
repl_sigint_act.sa_sigaction = repl_sigint_handler;
repl_sigint_act.sa_flags = SA_SIGINFO;
if (sigaction(SIGINT, &repl_sigint_act, &oldact) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
if (repl_sigint_act.sa_sigaction != oldact.sa_sigaction &&
jl_sigint_act.sa_sigaction != oldact.sa_sigaction)
jl_sigint_act = oldact;
}
#endif
}
static size_t pool_stats(pool_t *p, size_t *pwaste)
{
gcval_t *v;
gcpage_t *pg = p->pages;
size_t osize = p->osize;
size_t nused=0, nfree=0, npgs=0;
while (pg != NULL) {
npgs++;
v = (gcval_t*)&pg->data[0];
char *lim = (char*)v + GC_PAGE_SZ - osize;
while ((char*)v <= lim) {
if (!v->marked) {
nfree++;
}
else {
nused++;
}
v = (gcval_t*)((char*)v + osize);
}
gcpage_t *nextpg = pg->next;
pg = nextpg;
}
*pwaste = npgs*GC_PAGE_SZ - (nused*p->osize);
JL_PRINTF(JL_STDOUT,
"%4d : %7d/%7d objects, %5d pages, %8d bytes, %8d waste\n",
p->osize,
nused,
nused+nfree,
npgs,
nused*p->osize,
*pwaste);
return nused*p->osize;
}
void jl_gc_collect(void)
{
allocd_bytes = 0;
if (is_gc_enabled) {
freed_bytes = 0;
JL_SIGATOMIC_BEGIN();
#if defined(GCTIME) || defined(GC_FINAL_STATS)
double t0 = clock_now();
#endif
gc_mark();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "mark time %.3f ms\n", (clock_now()-t0)*1000);
#endif
#if defined(MEMPROFILE)
all_pool_stats();
big_obj_stats();
#endif
#ifdef GCTIME
t0 = clock_now();
#endif
sweep_weak_refs();
gc_sweep();
#ifdef GCTIME
JL_PRINTF(JL_STDERR, "sweep time %.3f ms\n", (clock_now()-t0)*1000);
#endif
run_finalizers();
JL_SIGATOMIC_END();
#if defined(GC_FINAL_STATS)
total_gc_time += (clock_now()-t0);
total_freed_bytes += freed_bytes;
#endif
#ifdef OBJPROFILE
print_obj_profile();
htable_reset(&obj_counts, 0);
#endif
// tune collect interval based on current live ratio
if (freed_bytes < ((2*collect_interval)/5)) {
if (collect_interval <= (2*max_collect_interval)/5)
collect_interval = (5*collect_interval)/2;
}
else {
collect_interval = default_collect_interval;
}
}
}
void *jl_dlsym(uv_lib_t *handle, char *symbol)
{
void *ptr;
int error = uv_dlsym(handle, symbol, &ptr);
if (error != 0) {
JL_PRINTF(JL_STDERR, "symbol could not be found %s (%d): %s\n", symbol, error, uv_dlerror(handle));
}
return ptr;
}
void *jl_dlsym(uv_lib_t *handle, char *symbol)
{
void *ptr;
int error = uv_dlsym(handle, symbol, &ptr);
if (error != 0) {
JL_PRINTF(JL_STDERR, "symbol could not be found %s (%d): %s", symbol, error, handle->errmsg!=NULL?handle->errmsg:"");
}
return ptr;
}
void jl_error(const char *str)
{
if (jl_errorexception_type == NULL) {
JL_PRINTF(JL_STDERR, "%s", str);
jl_exit(1);
}
jl_value_t *msg = jl_pchar_to_string((char*)str, strlen(str));
JL_GC_PUSH(&msg);
jl_raise(jl_new_struct(jl_errorexception_type, msg));
}
void jl_module_run_initializer(jl_module_t *m)
{
jl_value_t *f = jl_get_global(m, jl_symbol("__init__"));
if (f == NULL || !jl_is_function(f))
return;
int build_mode = (jl_compileropts.build_path != NULL);
if (build_mode) {
if (jl_module_init_order == NULL)
jl_module_init_order = jl_alloc_cell_1d(0);
jl_cell_1d_push(jl_module_init_order, (jl_value_t*)m);
}
JL_TRY {
jl_apply((jl_function_t*)f, NULL, 0);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "Warning: error initializing module %s:\n", m->name->name);
jl_static_show(JL_STDERR, jl_exception_in_transit);
JL_PRINTF(JL_STDERR, "\n");
}
}
void jl_add_constructors(jl_datatype_t *t)
{
if (t->name == jl_array_typename) {
t->fptr = jl_f_no_function;
return;
}
jl_initialize_generic_function((jl_function_t*)t, t->name->name);
if (t->name->ctor_factory == (jl_value_t*)jl_nothing ||
t->name->ctor_factory == (jl_value_t*)jl_null) {
}
else {
assert(jl_tuple_len(t->parameters) > 0);
if (t == (jl_datatype_t*)t->name->primary)
return;
jl_function_t *cfactory = NULL;
jl_tuple_t *env = NULL;
JL_GC_PUSH2(&cfactory, &env);
if (jl_compileropts.compile_enabled) {
// instantiating
assert(jl_is_function(t->name->ctor_factory));
// add type's static parameters to the ctor factory
size_t np = jl_tuple_len(t->parameters);
env = jl_alloc_tuple_uninit(np*2);
for(size_t i=0; i < np; i++) {
jl_tupleset(env, i*2+0,
jl_tupleref(((jl_datatype_t*)t->name->primary)->parameters, i));
jl_tupleset(env, i*2+1,
jl_tupleref(t->parameters, i));
}
cfactory = jl_instantiate_method((jl_function_t*)t->name->ctor_factory, env);
cfactory->linfo->ast = jl_prepare_ast(cfactory->linfo,
cfactory->linfo->sparams);
}
else {
cfactory = ((jl_datatype_t*)t)->name->static_ctor_factory;
if (cfactory == NULL) {
JL_PRINTF(JL_STDERR,"code missing for type %s\n", t->name->name);
exit(1);
}
// in generically-compiled case, pass static parameters via closure
// environment.
env = jl_tuple_append((jl_tuple_t*)cfactory->env, t->parameters);
cfactory = jl_new_closure(cfactory->fptr, (jl_value_t*)env, cfactory->linfo);
}
// call user-defined constructor factory on (type,)
jl_value_t *cfargs[1] = { (jl_value_t*)t };
jl_apply(cfactory, cfargs, 1);
JL_GC_POP();
}
}
DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_value_t *rhs)
{
if (b->constp && b->value != NULL) {
if (!jl_egal(rhs, b->value)) {
if (jl_typeof(rhs) != jl_typeof(b->value) ||
jl_is_type(rhs) || jl_is_function(rhs) || jl_is_module(rhs)) {
jl_errorf("invalid redefinition of constant %s", b->name->name);
}
JL_PRINTF(JL_STDERR,"Warning: redefining constant %s\n",b->name->name);
}
}
b->value = rhs;
}
DLLEXPORT void jl_install_sigint_handler()
{
#ifdef __WIN32__
if (!DuplicateHandle( GetCurrentProcess(), GetCurrentThread(),
GetCurrentProcess(), (PHANDLE)&hMainThread, 0,
TRUE, DUPLICATE_SAME_ACCESS )) {
JL_PRINTF(JL_STDERR, "Couldn't access handle to main thread\n");
}
SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigint_handler,1);
#else
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = sigint_handler;
act.sa_flags = SA_SIGINFO;
if (sigaction(SIGINT, &act, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
#endif
//printf("sigint installed\n");
}
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;
}
DLLEXPORT int jl_profile_start_timer(void)
{
kern_return_t ret;
if (!profile_started) {
mach_port_t self = mach_task_self();
main_thread = mach_thread_self();
ret = host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, (clock_serv_t *)&clk);
HANDLE_MACH_ERROR("host_get_clock_service", ret);
ret = mach_port_allocate(self,MACH_PORT_RIGHT_RECEIVE,&profile_port);
HANDLE_MACH_ERROR("mach_port_allocate",ret);
// Alright, create a thread to serve as the listener for exceptions
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(&profiler_thread,&attr,mach_profile_listener,NULL) != 0) {
JL_PRINTF(JL_STDERR, "pthread_create failed");
jl_exit(1);
}
pthread_attr_destroy(&attr);
profile_started = 1;
}
timerprof.tv_sec = nsecprof/GIGA;
timerprof.tv_nsec = nsecprof%GIGA;
running = 1;
ret = clock_alarm(clk, TIME_RELATIVE, timerprof, profile_port);
HANDLE_MACH_ERROR("clock_alarm",ret);
return 0;
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
ios_t *s = (ios_t*)jl_iostr_data(str);
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "#<intrinsic-function %d>", *(uint32_t*)jl_bits_data(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
assert(jl_is_struct_type(t) || jl_is_bits_type(t));
jl_tag_type_t *tt = (jl_tag_type_t*)t;
JL_PUTS(tt->name->name->name, s);
if (tt->parameters != jl_null) {
jl_show_tuple(str, tt->parameters, '{', '}', 0);
}
JL_PUTC('(', s);
if (jl_is_struct_type(tt)) {
jl_struct_type_t *st = (jl_struct_type_t*)tt;
size_t i;
size_t n = jl_tuple_len(st->names);
for(i=0; i < n; i++) {
jl_value_t *fval = jl_get_nth_field(v, i);
if (fval == NULL)
JL_PUTS("#undef", s);
else
jl_show(str, fval);
if (i < n-1)
JL_PUTC(',', s);
}
}
else {
size_t nb = jl_bitstype_nbits(tt)/8;
char *data = (char*)jl_bits_data(v);
JL_PUTS("0x", s);
for(int i=nb-1; i >= 0; --i)
ios_printf(s, "%02hhx", data[i]);
}
JL_PUTC(')', s);
}
}
void jl_errorf(const char *fmt, ...)
{
char buf[1024];
va_list args;
va_start(args, fmt);
int nc = vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
if (jl_errorexception_type == NULL) {
JL_PRINTF(JL_STDERR, "%s", &buf);
jl_exit(1);
}
jl_value_t *msg = jl_pchar_to_string(buf, nc);
JL_GC_PUSH(&msg);
jl_raise(jl_new_struct(jl_errorexception_type, msg));
}
void jl_errorf(const char *fmt, ...)
{
va_list args;
ios_t buf;
ios_mem(&buf, 0);
va_start(args, fmt);
ios_vprintf(&buf, fmt, args);
va_end(args);
if (jl_errorexception_type == NULL) {
JL_PRINTF(JL_STDERR, "%s", buf.buf);
jl_exit(1);
}
jl_value_t *msg = jl_takebuf_string(&buf);
JL_GC_PUSH1(&msg);
jl_throw(jl_new_struct(jl_errorexception_type, msg));
}
void jl_show(jl_value_t *stream, jl_value_t *v)
{
if (jl_base_module) {
if (jl_show_gf == NULL) {
jl_show_gf = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("show"));
}
if (jl_show_gf==NULL || stream==NULL) {
JL_PRINTF(JL_STDERR, " could not show value of type %s",
jl_is_tuple(v) ? "Tuple" :
((jl_datatype_t*)jl_typeof(v))->name->name->name);
return;
}
jl_value_t *args[2] = {stream,v};
jl_apply(jl_show_gf, args, 2);
}
}
static void big_obj_stats(void)
{
bigval_t *v = big_objects;
size_t nused=0, nbytes=0;
while (v != NULL) {
if (v->isobj && (bigval_word0(v)&1)) {
nused++;
nbytes += v->sz;
}
else if (!v->isobj && v->marked) {
nused++;
nbytes += v->sz;
}
v = v->next;
}
JL_PRINTF(JL_STDOUT, "%d bytes in %d large objects\n", nbytes, nused);
}
DLLEXPORT void uv_atexit_hook()
{
#if defined(JL_GC_MARKSWEEP) && defined(GC_FINAL_STATS)
jl_print_gc_stats(JL_STDERR);
#endif
if (jl_base_module) {
jl_value_t *f = jl_get_global(jl_base_module, jl_symbol("_atexit"));
if (f!=NULL && jl_is_function(f)) {
JL_TRY {
jl_apply((jl_function_t*)f, NULL, 0);
}
JL_CATCH {
JL_PRINTF(JL_STDERR, "\natexit hook threw an error: ");
jl_show(jl_stderr_obj(),jl_exception_in_transit);
}
}
}
DLLEXPORT void jl_install_sigint_handler()
{
#ifdef _OS_WINDOWS_
SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigint_handler,1);
#else
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
sigemptyset(&act.sa_mask);
act.sa_sigaction = sigint_handler;
act.sa_flags = SA_SIGINFO;
if (sigaction(SIGINT, &act, NULL) < 0) {
JL_PRINTF(JL_STDERR, "sigaction: %s\n", strerror(errno));
jl_exit(1);
}
#endif
//printf("sigint installed\n");
}
DLLEXPORT void jl_show_any(jl_value_t *str, jl_value_t *v)
{
uv_stream_t *s = ((uv_stream_t**)str)[1];
// fallback for printing some other builtin types
if (jl_is_tuple(v)) {
jl_show_tuple(str, (jl_tuple_t*)v, '(', ')', 1);
}
else if (jl_is_type(v)) {
show_type(str, v);
}
else if (jl_is_func(v)) {
show_function(s, v);
}
else if (jl_typeis(v,jl_intrinsic_type)) {
JL_PRINTF(s, "# intrinsic function %d", *(uint32_t*)jl_data_ptr(v));
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
assert(jl_is_datatype(t));
jl_datatype_t *dt = (jl_datatype_t*)t;
show_type(str, t);
JL_PUTC('(', s);
if (jl_tuple_len(dt->names)>0 || dt->size==0) {
size_t i;
size_t n = jl_tuple_len(dt->names);
for(i=0; i < n; i++) {
jl_value_t *fval = jl_get_nth_field(v, i);
if (fval == NULL)
JL_PUTS("#undef", s);
else
jl_show(str, fval);
if (i < n-1)
JL_PUTC(',', s);
}
}
else {
size_t nb = jl_datatype_size(dt);
char *data = (char*)jl_data_ptr(v);
JL_PUTS("0x", s);
for(int i=nb-1; i >= 0; --i)
jl_printf(s, "%02hhx", data[i]);
}
JL_PUTC(')', s);
}
}
static void all_pool_stats(void)
{
int i;
size_t nb=0, w, tw=0, no=0, b;
for(i=0; i < N_POOLS; i++) {
b = pool_stats(&norm_pools[i], &w);
nb += b;
no += (b/norm_pools[i].osize);
tw += w;
b = pool_stats(&ephe_pools[i], &w);
nb += b;
no += (b/ephe_pools[i].osize);
tw += w;
}
JL_PRINTF(JL_STDOUT,
"%d objects, %d total allocated, %d total fragments\n",
no, nb, tw);
}
DLLEXPORT void jl_init_frontend(void)
{
fl_init(2*512*1024);
value_t img = cvalue(iostreamtype, sizeof(ios_t));
ios_t *pi = value2c(ios_t*, img);
ios_static_buffer(pi, flisp_system_image, sizeof(flisp_system_image));
if (fl_load_system_image(img)) {
JL_PRINTF(JL_STDERR, "fatal error loading system image\n");
jl_exit(1);
}
fl_applyn(0, symbol_value(symbol("__init_globals")));
jvtype = define_opaque_type(symbol("julia_value"), sizeof(void*),
NULL, NULL);
assign_global_builtins(julia_flisp_ast_ext);
}
