/// Overload for void pointer
void push_back(const ValueT& val)
{
JL_GC_PUSH1(&m_array);
const size_t pos = jl_array_len(m_array);
jl_array_grow_end(m_array, 1);
jl_arrayset(m_array, (jl_value_t*)(convert_to_julia(val)), pos);
JL_GC_POP();
}
void jl_arrayunset(jl_array_t *a, size_t i)
{
if (i >= jl_array_len(a))
jl_throw(jl_bounds_exception);
char *ptail = (char*)a->data + i*a->elsize;
if (a->ptrarray)
memset(ptail, 0, a->elsize);
}
// TODO: eval decl types for arguments of non-generic functions
static void eval_decl_types(jl_array_t *vi, jl_tuple_t *spenv)
{
size_t i;
for(i=0; i < jl_array_len(vi); i++) {
jl_array_t *v = (jl_array_t*)jl_cellref(vi, i);
assert(jl_array_len(v) > 1);
JL_TRY {
jl_value_t *ty =
jl_interpret_toplevel_expr_with(jl_cellref(v,1),
&jl_tupleref(spenv,0),
jl_tuple_len(spenv)/2);
jl_cellref(v, 1) = ty;
}
JL_CATCH {
}
}
}
static union jl_typemap_t *mtcache_hash_bp(struct jl_ordereddict_t *pa, jl_value_t *ty,
int8_t tparam, int8_t offs, jl_value_t *parent)
{
if (jl_is_datatype(ty)) {
uintptr_t uid = ((jl_datatype_t*)ty)->uid;
if (!uid || jl_is_kind(ty) || jl_has_free_typevars(ty))
// be careful not to put non-leaf types or DataType/UnionAll in the cache here,
// since they should have a lower priority and need to go into the sorted list
return NULL;
if (pa->values == (void*)jl_nothing) {
pa->indices = jl_alloc_int_1d(0, INIT_CACHE_SIZE);
jl_gc_wb(parent, pa->indices);
pa->values = jl_alloc_vec_any(0);
jl_gc_wb(parent, pa->values);
}
while (1) {
size_t slot = uid & (pa->indices->nrows - 1);
size_t idx = jl_intref(pa->indices, slot);
if (idx == 0) {
jl_array_ptr_1d_push(pa->values, jl_nothing);
idx = jl_array_len(pa->values);
if (idx > jl_max_int(pa->indices))
mtcache_rehash(pa, jl_array_len(pa->indices), parent, tparam, offs);
jl_intset(pa->indices, slot, idx);
return &((union jl_typemap_t*)jl_array_data(pa->values))[idx - 1];
}
union jl_typemap_t *pml = &((union jl_typemap_t*)jl_array_data(pa->values))[idx - 1];
if (pml->unknown == jl_nothing)
return pml;
jl_value_t *t;
if (jl_typeof(pml->unknown) == (jl_value_t*)jl_typemap_level_type) {
t = pml->node->key;
}
else {
assert(jl_typeof(pml->unknown) == (jl_value_t*)jl_typemap_entry_type);
t = jl_field_type(jl_unwrap_unionall((jl_value_t*)pml->leaf->sig), offs);
if (tparam)
t = jl_tparam0(t);
}
if (t == ty)
return pml;
mtcache_rehash(pa, jl_array_len(pa->indices) * 2, parent, tparam, offs);
}
}
return NULL;
}
jl_value_t *skip_meta(jl_array_t *body)
{
jl_value_t *body1 = jl_array_ptr_ref(body,0);
if (jl_is_expr(body1) && ((jl_expr_t*)body1)->head == meta_sym
&& jl_array_len(body) > 1)
body1 = jl_array_ptr_ref(body,1);
return body1;
}
void jl_arrayunset(jl_array_t *a, size_t i)
{
if (i >= jl_array_len(a))
jl_bounds_error_int((jl_value_t*)a, i+1);
char *ptail = (char*)a->data + i*a->elsize;
if (a->ptrarray)
memset(ptail, 0, a->elsize);
}
static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
{
// in .A.B.C, first find a binding for A in the chain of module scopes
// following parent links. then evaluate the rest of the path from there.
// in A.B, look for A in Main first.
jl_sym_t *var = (jl_sym_t*)jl_cellref(args,0);
size_t i=1;
assert(jl_is_symbol(var));
jl_module_t *m;
if (var != dot_sym) {
m = jl_main_module;
}
else {
m = jl_current_module;
while (1) {
var = (jl_sym_t*)jl_cellref(args,i);
i++;
if (var != dot_sym)
break;
m = m->parent;
}
}
while (1) {
if (jl_binding_resolved_p(m, var)) {
jl_binding_t *mb = jl_get_binding(m, var);
assert(mb != NULL);
if (mb->value == NULL || !jl_is_module(mb->value))
jl_errorf("invalid module path");
m = (jl_module_t*)mb->value;
break;
}
if (m == jl_main_module) {
if (!retrying) {
if (require_func == NULL && jl_base_module != NULL)
require_func = jl_get_global(jl_base_module, jl_symbol("require"));
if (require_func != NULL) {
jl_value_t *str = jl_cstr_to_string(var->name);
JL_GC_PUSH1(&str);
jl_apply((jl_function_t*)require_func, &str, 1);
JL_GC_POP();
return eval_import_path_(args, 1);
}
}
}
jl_errorf("in module path: %s not defined", var->name);
}
for(; i < jl_array_len(args)-1; i++) {
jl_value_t *s = jl_cellref(args,i);
assert(jl_is_symbol(s));
m = (jl_module_t*)jl_eval_global_var(m, (jl_sym_t*)s);
if (!jl_is_module(m))
jl_errorf("invalid import statement");
}
return m;
}
static int has_intrinsics(jl_expr_t *e)
{
if (jl_array_len(e->args) == 0)
return 0;
if (e->head == static_typeof_sym) return 1;
jl_value_t *e0 = jl_exprarg(e,0);
if (e->head == call_sym &&
((jl_is_symbol(e0) && is_intrinsic(jl_current_module,(jl_sym_t*)e0)) ||
(jl_is_topnode(e0) && is_intrinsic(jl_base_relative_to(jl_current_module),(jl_sym_t*)jl_fieldref(e0,0)))))
return 1;
int i;
for(i=0; i < jl_array_len(e->args); i++) {
jl_value_t *a = jl_exprarg(e,i);
if (jl_is_expr(a) && has_intrinsics((jl_expr_t*)a))
return 1;
}
return 0;
}
void juliaProblem::EucGrad(Variable *x, Vector *egf) const
{
// x->Print("cpp gf x");//---
jl_value_t* array_type = jl_apply_array_type(jl_float64_type, 1);
double *xptr = x->ObtainWritePartialData();
jl_array_t *arrx = jl_ptr_to_array_1d(array_type, xptr, x->Getlength(), 0);
jl_array_t *arrtmp = nullptr;
if(x->TempDataExist(("Tmp")))
{
const SharedSpace *Tmp = x->ObtainReadTempData("Tmp");
// Tmp->Print("cpp gf inTmp");//---
const double *tmpptr = Tmp->ObtainReadData();
arrtmp = jl_ptr_to_array_1d(array_type, const_cast<double *> (tmpptr), Tmp->Getlength(), 0);
} else
{
arrtmp = jl_ptr_to_array_1d(array_type, nullptr, 0, 0);
}
jl_value_t *retresult = jl_call2(jl_gf, (jl_value_t *) arrx, (jl_value_t *) arrtmp);
jl_array_t *jl_egf = (jl_array_t *) jl_get_nth_field(retresult, 0);
jl_array_t *outtmp = (jl_array_t *) jl_get_nth_field(retresult, 1);
if(jl_array_len(jl_egf) != egf->Getlength())
{
std::cout << "error: the size of the Euclidean gradient is not correct!" << std::endl;
exit(EXIT_FAILURE);
}
integer egflen = egf->Getlength();
double *egfptr = egf->ObtainWriteEntireData();
dcopy_(&egflen, (double*)jl_array_data(jl_egf), &GLOBAL::IONE, egfptr, &GLOBAL::IONE);
// egf->Print("cpp gf egf:");//--
integer outtmplen = jl_array_len(outtmp);
if(outtmplen != 0)
{
SharedSpace *sharedouttmp = new SharedSpace(1, outtmplen);
double *outtmpptr = sharedouttmp->ObtainWriteEntireData();
dcopy_(&outtmplen, (double*)jl_array_data(outtmp), &GLOBAL::IONE, outtmpptr, &GLOBAL::IONE);
x->RemoveFromTempData("Tmp");
x->AddToTempData("Tmp", sharedouttmp);
}
};
int true_main(int argc, char *argv[])
{
if (jl_base_module != NULL) {
jl_array_t *args = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("ARGS"));
assert(jl_array_len(args) == 0);
jl_array_grow_end(args, argc);
int i;
for (i=0; i < argc; i++) {
jl_value_t *s = (jl_value_t*)jl_cstr_to_string(argv[i]);
s->type = (jl_value_t*)jl_utf8_string_type;
jl_arrayset(args, s, i);
}
}
// run program if specified, otherwise enter REPL
if (program) {
int ret = exec_program();
uv_tty_reset_mode();
return ret;
}
jl_function_t *start_client =
(jl_function_t*)jl_get_global(jl_base_module, jl_symbol("_start"));
//uv_read_start(jl_stdin_tty,jl_alloc_read_buffer,&read_buffer);
if (start_client) {
jl_apply(start_client, NULL, 0);
//rl_cleanup_after_signal();
return 0;
}
// client event loop not available; use fallback blocking version
//install_read_event_handler(&echoBack);
int iserr = 0;
again:
;
JL_TRY {
if (iserr) {
//jl_show(jl_exception_in_transit);# What if the error was in show?
jl_printf(JL_STDERR, "\n\n");
iserr = 0;
}
uv_run(jl_global_event_loop(),UV_RUN_DEFAULT);
}
JL_CATCH {
iserr = 1;
JL_PUTS("error during run:\n",JL_STDERR);
jl_show(jl_stderr_obj(),jl_exception_in_transit);
JL_PUTS("\n",JL_STDOUT);
goto again;
}
uv_tty_reset_mode();
return iserr;
}
static
jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tuple_t *type,
jl_function_t *method)
{
jl_methlist_t **pml = &mt->cache;
if (type->length > 0) {
jl_value_t *t0 = jl_t0(type);
uptrint_t uid=0;
// if t0 != jl_typetype_type and the argument is Type{...}, this
// method has specializations for singleton kinds and we use
// the table indexed for that purpose.
if (t0 != (jl_value_t*)jl_typetype_type && jl_is_type_type(t0)) {
jl_value_t *a0 = jl_tparam0(t0);
if (jl_is_struct_type(a0))
uid = ((jl_struct_type_t*)a0)->uid;
else if (jl_is_bits_type(a0))
uid = ((jl_bits_type_t*)a0)->uid;
if (uid > 0) {
if (mt->cache_targ == NULL)
mt->cache_targ = jl_alloc_cell_1d(0);
if (uid >= jl_array_len(mt->cache_targ)) {
jl_array_grow_end(mt->cache_targ, uid+4-jl_array_len(mt->cache_targ));
}
pml = (jl_methlist_t**)&jl_cellref(mt->cache_targ, uid);
goto ml_do_insert;
}
}
if (jl_is_struct_type(t0))
uid = ((jl_struct_type_t*)t0)->uid;
else if (jl_is_bits_type(t0))
uid = ((jl_bits_type_t*)t0)->uid;
if (uid > 0) {
if (mt->cache_arg1 == NULL)
mt->cache_arg1 = jl_alloc_cell_1d(0);
if (uid >= jl_array_len(mt->cache_arg1)) {
jl_array_grow_end(mt->cache_arg1, uid+4-jl_array_len(mt->cache_arg1));
}
pml = (jl_methlist_t**)&jl_cellref(mt->cache_arg1, uid);
}
}
ml_do_insert:
return jl_method_list_insert(pml, type, method, jl_null, 0)->func;
}
int jl_lam_vars_captured(jl_expr_t *ast)
{
jl_array_t *vinfos = jl_lam_vinfo(ast);
for(int i=0; i < jl_array_len(vinfos); i++) {
if (jl_vinfo_capt((jl_array_t*)jl_cellref(vinfos,i))) {
return 1;
}
}
return 0;
}
DLLEXPORT
jl_value_t *jl_uncompress_ast(jl_tuple_t *data)
{
jl_array_t *bytes = (jl_array_t*)jl_tupleref(data, 0);
tree_literal_values = (jl_array_t*)jl_tupleref(data, 1);
ios_t src;
ios_mem(&src, 0);
ios_setbuf(&src, bytes->data, jl_array_len(bytes), 0);
src.size = jl_array_len(bytes);
int en = jl_gc_is_enabled();
jl_gc_disable();
jl_gc_ephemeral_on();
jl_value_t *v = jl_deserialize_value(&src);
jl_gc_ephemeral_off();
if (en)
jl_gc_enable();
tree_literal_values = NULL;
return v;
}
jl_value_t *jl_array_to_string(jl_array_t *a)
{
// TODO: check type of array?
jl_datatype_t* string_type = u8_isvalid(a->data, jl_array_len(a)) == 1 ? // ASCII
jl_ascii_string_type : jl_utf8_string_type;
jl_value_t *s = alloc_2w();
s->type = (jl_value_t*)string_type;
jl_set_nth_field(s, 0, (jl_value_t*)a);
return s;
}
static int jl_typemap_array_visitor(struct jl_ordereddict_t *a, jl_typemap_visitor_fptr fptr, void *closure)
{
size_t i, l = jl_array_len(a->values);
union jl_typemap_t *data = (union jl_typemap_t*)jl_array_data(a->values);
for(i=0; i < l; i++) {
if (!jl_typemap_visitor(data[i], fptr, closure))
return 0;
}
return 1;
}
void jl_lambda_info_set_ast(jl_lambda_info_t *li, jl_value_t *ast)
{
assert(jl_is_expr(ast));
jl_array_t *body = jl_lam_body((jl_expr_t*)ast)->args;
li->code = body; jl_gc_wb(li, li->code);
if (has_meta(body, pure_sym))
li->pure = 1;
jl_array_t *vis = jl_lam_vinfo((jl_expr_t*)ast);
size_t nslots = jl_array_len(vis);
jl_value_t *ssavalue_types = jl_lam_ssavalues((jl_expr_t*)ast);
assert(jl_is_long(ssavalue_types));
size_t nssavalue = jl_unbox_long(ssavalue_types);
li->slotnames = jl_alloc_cell_1d(nslots);
jl_gc_wb(li, li->slotnames);
li->slottypes = jl_nothing;
li->slotflags = jl_alloc_array_1d(jl_array_uint8_type, nslots);
jl_gc_wb(li, li->slotflags);
li->ssavaluetypes = jl_box_long(nssavalue);
jl_gc_wb(li, li->ssavaluetypes);
int i;
for(i=0; i < nslots; i++) {
jl_value_t *vi = jl_cellref(vis, i);
jl_sym_t *name = (jl_sym_t*)jl_cellref(vi, 0);
assert(jl_is_symbol(name));
char *str = jl_symbol_name(name);
if (i > 0 && name != unused_sym) {
if (str[0] == '#') {
// convention for renamed variables: #...#original_name
char *nxt = strchr(str + 1, '#');
if (nxt)
name = jl_symbol(nxt+1);
else if (str[1] == 's') // compiler-generated temporaries, #sXXX
name = compiler_temp_sym;
}
}
jl_cellset(li->slotnames, i, name);
jl_array_uint8_set(li->slotflags, i, jl_unbox_long(jl_cellref(vi, 2)));
}
jl_array_t *args = jl_lam_args((jl_expr_t*)ast);
size_t narg = jl_array_len(args);
li->nargs = narg;
li->isva = narg > 0 && jl_is_rest_arg(jl_cellref(args, narg - 1));
}
void jl_typemap_rehash_array(struct jl_ordereddict_t *pa, jl_value_t *parent, int8_t tparam, int8_t offs) {
size_t i, len = jl_array_len(pa->values);
for (i = 0; i < len; i++) {
union jl_typemap_t ml;
ml.unknown = jl_array_ptr_ref(pa->values, i);
assert(ml.unknown != NULL);
jl_typemap_rehash(ml, offs+1);
}
mtcache_rehash(pa, 4 * next_power_of_two(len), parent, tparam, offs);
}
int jl_has_intrinsics(jl_expr_t *ast, jl_expr_t *e, jl_module_t *m)
{
if (jl_array_len(e->args) == 0)
return 0;
if (e->head == static_typeof_sym) return 1;
jl_value_t *e0 = jl_exprarg(e,0);
if (e->head == call_sym) {
jl_value_t *sv = jl_static_eval(e0, NULL, m, (jl_value_t*)jl_emptysvec, ast, 0, 0);
if (sv && jl_typeis(sv, jl_intrinsic_type))
return 1;
}
int i;
for(i=0; i < jl_array_len(e->args); i++) {
jl_value_t *a = jl_exprarg(e,i);
if (jl_is_expr(a) && jl_has_intrinsics(ast, (jl_expr_t*)a, m))
return 1;
}
return 0;
}
std::vector<SqwBase::t_var> SqwJl::GetVars() const
{
std::vector<SqwBase::t_var> vecVars;
if(!m_bOk)
{
tl::log_err("Julia interpreter has not initialised, cannot get variables.");
return vecVars;
}
jl_function_t *pNames = jl_get_function(jl_base_module, "names");
jl_function_t *pGetField = jl_get_function(jl_base_module, "getfield");
jl_function_t *pPrint = jl_get_function(jl_base_module, "string");
if(!pNames || !pGetField || !pPrint)
{
tl::log_err("Required Julia functions not available.");
return vecVars;
}
jl_array_t* pArrNames = (jl_array_t*)jl_call1(pNames, (jl_value_t*)jl_main_module);
if(!pArrNames)
return vecVars;
std::size_t iSyms = jl_array_len(pArrNames);
for(std::size_t iSym=0; iSym<iSyms; ++iSym)
{
jl_sym_t* pSym = (jl_sym_t*)jl_array_ptr_ref(pArrNames, iSym);
if(!pSym) continue;
// name
std::string strName = jl_symbol_name(pSym);
if(strName.length() == 0) continue;
// type
jl_value_t* pFld = jl_call2(pGetField, (jl_value_t*)jl_main_module, (jl_value_t*)pSym);
if(!pFld) continue;
std::string strType = jl_typeof_str(pFld);
if(strType.length() == 0) continue;
if(strType[0] == '#' || strType == "Module") continue; // filter funcs and mods
// value
jl_value_t* pFldPr = jl_call1(pPrint, pFld);
if(!pFldPr) continue;
std::string strValue = jl_string_ptr(pFldPr);
SqwBase::t_var var;
std::get<0>(var) = std::move(strName);
std::get<1>(var) = std::move(strType);
std::get<2>(var) = std::move(strValue);
vecVars.push_back(var);
}
return vecVars;
}
int true_main(int argc, char *argv[])
{
if (jl_base_module != NULL) {
jl_array_t *args = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("ARGS"));
if (args == NULL) {
args = jl_alloc_cell_1d(0);
jl_set_const(jl_base_module, jl_symbol("ARGS"), (jl_value_t*)args);
}
assert(jl_array_len(args) == 0);
jl_array_grow_end(args, argc);
int i;
for (i=0; i < argc; i++) {
jl_value_t *s = (jl_value_t*)jl_cstr_to_string(argv[i]);
s->type = (jl_value_t*)jl_utf8_string_type;
jl_arrayset(args, s, i);
}
}
// run program if specified, otherwise enter REPL
if (program) {
int ret = exec_program();
uv_tty_reset_mode();
return ret;
}
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;
}
int iserr = 0;
again:
;
JL_TRY {
if (iserr) {
//jl_show(jl_exception_in_transit);# What if the error was in show?
jl_printf(JL_STDERR, "\n\n");
iserr = 0;
}
uv_run(jl_global_event_loop(),UV_RUN_DEFAULT);
}
JL_CATCH {
iserr = 1;
JL_PUTS("error during run:\n",JL_STDERR);
jl_show(jl_stderr_obj(),jl_exception_in_transit);
JL_PUTS("\n",JL_STDOUT);
goto again;
}
uv_tty_reset_mode();
return iserr;
}
jl_value_t *jl_array_to_string(jl_array_t *a)
{
if (!jl_typeis(a, jl_array_uint8_type))
jl_type_error("jl_array_to_string", (jl_value_t*)jl_array_uint8_type, (jl_value_t*)a);
jl_datatype_t *string_type = u8_isvalid((char*)a->data, jl_array_len(a)) == 1 ? // ASCII
jl_ascii_string_type : jl_utf8_string_type;
jl_value_t *s = (jl_value_t*)jl_gc_alloc_1w();
jl_set_typeof(s, string_type);
jl_set_nth_field(s, 0, (jl_value_t*)a);
return s;
}
static int jl_typemap_array_visitor(jl_array_t *a, jl_typemap_visitor_fptr fptr, void *closure)
{
size_t i, l = jl_array_len(a);
jl_value_t **data = (jl_value_t**)jl_array_data(a);
for(i=0; i < l; i++) {
if (data[i] != NULL)
if (!jl_typemap_visitor(((union jl_typemap_t*)data)[i], fptr, closure))
return 0;
}
return 1;
}
static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule, jl_module_t **ctx)
{
jl_ptls_t ptls = jl_get_ptls_states();
JL_TIMING(MACRO_INVOCATION);
size_t nargs = jl_array_len(args) + 1;
JL_NARGSV("macrocall", 3); // macro name, location, and module
jl_value_t **margs;
JL_GC_PUSHARGS(margs, nargs);
int i;
margs[0] = jl_array_ptr_ref(args, 0);
// __source__ argument
jl_value_t *lno = jl_array_ptr_ref(args, 1);
margs[1] = lno;
if (!jl_typeis(lno, jl_linenumbernode_type)) {
margs[1] = jl_new_struct(jl_linenumbernode_type, jl_box_long(0), jl_nothing);
}
margs[2] = (jl_value_t*)inmodule;
for (i = 3; i < nargs; i++)
margs[i] = jl_array_ptr_ref(args, i - 1);
size_t last_age = ptls->world_age;
size_t world = jl_world_counter;
ptls->world_age = world;
jl_value_t *result;
JL_TRY {
margs[0] = jl_toplevel_eval(*ctx, margs[0]);
jl_method_instance_t *mfunc = jl_method_lookup(jl_gf_mtable(margs[0]), margs, nargs, 1, world);
if (mfunc == NULL) {
jl_method_error((jl_function_t*)margs[0], margs, nargs, world);
// unreachable
}
*ctx = mfunc->def.method->module;
result = mfunc->invoke(mfunc, margs, nargs);
}
JL_CATCH {
if (jl_loaderror_type == NULL) {
jl_rethrow();
}
else {
jl_value_t *lno = margs[1];
jl_value_t *file = jl_fieldref(lno, 1);
if (jl_is_symbol(file))
margs[0] = jl_cstr_to_string(jl_symbol_name((jl_sym_t*)file));
else
margs[0] = jl_cstr_to_string("<macrocall>");
margs[1] = jl_fieldref(lno, 0); // extract and allocate line number
jl_rethrow_other(jl_new_struct(jl_loaderror_type, margs[0], margs[1],
ptls->exception_in_transit));
}
}
ptls->world_age = last_age;
JL_GC_POP();
return result;
}
DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
{
if (jl_is_expr(expr)) {
jl_expr_t *e = (jl_expr_t*)expr;
size_t i, l = jl_array_len(e->args);
jl_expr_t *ne = NULL;
JL_GC_PUSH2(&ne, &expr);
ne = jl_exprn(e->head, l);
if (l == 0) {
ne->args = jl_alloc_cell_1d(0);
}
else {
for(i=0; i < l; i++)
jl_exprarg(ne, i) = jl_copy_ast(jl_exprarg(e,i));
}
JL_GC_POP();
return (jl_value_t*)ne;
}
else if (jl_typeis(expr,jl_array_any_type)) {
jl_array_t *a = (jl_array_t*)expr;
size_t i, l = jl_array_len(a);
jl_array_t *na = NULL;
JL_GC_PUSH2(&na, &expr);
na = jl_alloc_cell_1d(l);
for(i=0; i < l; i++)
jl_cellset(na, i, jl_copy_ast(jl_cellref(a,i)));
JL_GC_POP();
return (jl_value_t*)na;
}
else if (jl_is_quotenode(expr)) {
if (jl_is_symbol(jl_fieldref(expr,0)))
return expr;
jl_value_t *q = NULL;
JL_GC_PUSH2(&q, &expr);
q = jl_copy_ast(jl_fieldref(expr,0));
jl_value_t *v = jl_new_struct(jl_quotenode_type, q);
JL_GC_POP();
return v;
}
return expr;
}
int jl_is_rest_arg(jl_value_t *ex)
{
if (!jl_is_expr(ex)) return 0;
if (((jl_expr_t*)ex)->head != colons_sym) return 0;
jl_expr_t *atype = (jl_expr_t*)jl_exprarg(ex,1);
if (!jl_is_expr(atype)) return 0;
if (atype->head != call_sym || jl_array_len(atype->args) != 3)
return 0;
if ((jl_sym_t*)jl_exprarg(atype,1) != dots_sym)
return 0;
return 1;
}
//this function is for factor convert it maybe not safe
//because PooledDataArray.refs is Uint32 or bigger
//but in pratice it should be ok
static SEXP Julia_R_MD_INT(jl_value_t *Var)
{
SEXP ans = R_NilValue;
jl_value_t *val;
if (((jl_array_t *)Var)->ptrarray)
val = jl_cellref(Var, 0);
else
val = jl_arrayref((jl_array_t *)Var, 0);
int len = jl_array_len(Var);
if (len == 0) return ans;
if (jl_is_int32(val))
{
int32_t *p = (int32_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_int64(val))
{
int64_t *p = (int64_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_int8(val))
{
int8_t *p = (int8_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_int16(val))
{
int16_t *p = (int16_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_uint8(val))
{
uint8_t *p = (uint8_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_uint16(val))
{
uint16_t *p = (uint16_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_uint32(val))
{
uint32_t *p = (uint32_t *) jl_array_data(Var);
jlint_to_r_md;
}
else if (jl_is_uint64(val))
{
uint64_t *p = (uint64_t *) jl_array_data(Var);
jlint_to_r_md;
}
return ans;
}
static void jl_compile_specializations(void)
{
// this "found" array will contain function
// type signatures that were inferred but haven't been compiled
jl_array_t *m = jl_alloc_vec_any(0);
JL_GC_PUSH1(&m);
jl_foreach_mtable_in_module(jl_main_module, precompile_enq_all_specializations_, m);
size_t i, l;
for (i = 0, l = jl_array_len(m); i < l; i++) {
jl_compile_hint((jl_tupletype_t*)jl_array_ptr_ref(m, i));
}
JL_GC_POP();
}
static value_t array_to_list(jl_array_t *a)
{
long i;
value_t lst=FL_NIL, temp=FL_NIL;
fl_gc_handle(&lst);
fl_gc_handle(&temp);
for(i=jl_array_len(a)-1; i >= 0; i--) {
temp = julia_to_scm(jl_cellref(a,i));
lst = fl_cons(temp, lst);
}
fl_free_gc_handles(2);
return lst;
}
/*
Method caches are divided into three parts: one for signatures where
the first argument is a singleton kind (Type{Foo}), one indexed by the
UID of the first argument's type in normal cases, and a fallback
table of everything else.
*/
static jl_function_t *jl_method_table_assoc_exact_by_type(jl_methtable_t *mt,
jl_tuple_t *types)
{
jl_methlist_t *ml = NULL;
if (types->length > 0) {
jl_value_t *ty = jl_t0(types);
uptrint_t uid;
if (jl_is_type_type(ty)) {
jl_value_t *a0 = jl_tparam0(ty);
jl_value_t *tty = (jl_value_t*)jl_typeof(a0);
if ((tty == (jl_value_t*)jl_struct_kind && (uid = ((jl_struct_type_t*)a0)->uid)) ||
(tty == (jl_value_t*)jl_bits_kind && (uid = ((jl_bits_type_t*)a0)->uid))) {
if (mt->cache_targ &&
uid < jl_array_len(mt->cache_targ)) {
ml = (jl_methlist_t*)jl_cellref(mt->cache_targ, uid);
if (ml)
goto mt_assoc_bt_lkup;
}
}
}
if ((jl_is_struct_type(ty) && (uid = ((jl_struct_type_t*)ty)->uid)) ||
(jl_is_bits_type(ty) && (uid = ((jl_bits_type_t*)ty)->uid))) {
if (mt->cache_arg1 && uid < jl_array_len(mt->cache_arg1)) {
ml = (jl_methlist_t*)jl_cellref(mt->cache_arg1, uid);
}
}
}
if (ml == NULL)
ml = mt->cache;
mt_assoc_bt_lkup:
while (ml != NULL) {
if (cache_match_by_type(&jl_tupleref(types,0), types->length,
(jl_tuple_t*)ml->sig, ml->va==jl_true)) {
return ml->func;
}
ml = ml->next;
}
return NULL;
}
int jl_code_requires_compiler(jl_code_info_t *src)
{
jl_array_t *body = src->code;
assert(jl_typeis(body, jl_array_any_type));
size_t i;
int has_intrinsics = 0, has_defs = 0;
for(i=0; i < jl_array_len(body); i++) {
jl_value_t *stmt = jl_array_ptr_ref(body,i);
expr_attributes(stmt, &has_intrinsics, &has_defs);
if (has_intrinsics)
return 1;
}
return 0;
}
