JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from) { if (to == from) return; for(size_t i=0; i < to->usings.len; i++) { if (from == to->usings.items[i]) return; } // print a warning if something visible via this "using" conflicts with // an existing identifier. note that an identifier added later may still // silently override a "using" name. see issue #2054. void **table = from->bindings.table; for(size_t i=1; i < from->bindings.size; i+=2) { if (table[i] != HT_NOTFOUND) { jl_binding_t *b = (jl_binding_t*)table[i]; if (b->exportp && (b->owner==from || b->imported)) { jl_sym_t *var = (jl_sym_t*)table[i-1]; jl_binding_t **tobp = (jl_binding_t**)ptrhash_bp(&to->bindings, var); if (*tobp != HT_NOTFOUND && (*tobp)->owner != NULL && // don't warn for conflicts with the module name itself. // see issue #4715 var != to->name && !eq_bindings(jl_get_binding(to,var), b)) { jl_printf(JL_STDERR, "WARNING: using %s.%s in module %s conflicts with an existing identifier.\n", jl_symbol_name(from->name), jl_symbol_name(var), jl_symbol_name(to->name)); } } } } arraylist_push(&to->usings, from); }
static jl_sym_t *mk_symbol(const char *str, size_t len) { jl_sym_t *sym; size_t nb = symbol_nbytes(len); if (nb >= SYM_POOL_SIZE) { jl_exceptionf(jl_argumenterror_type, "Symbol length exceeds maximum length"); } jl_taggedvalue_t *tag; #ifdef MEMDEBUG tag = (jl_taggedvalue_t*)malloc(nb); #else static char *sym_pool = NULL; static char *pool_ptr = NULL; if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) { sym_pool = (char*)malloc(SYM_POOL_SIZE); pool_ptr = sym_pool; } tag = (jl_taggedvalue_t*)pool_ptr; pool_ptr += nb; #endif sym = (jl_sym_t*)jl_valueof(tag); // set to old marked since we don't need write barrier on it. tag->header = ((uintptr_t)jl_sym_type) | GC_OLD_MARKED; sym->left = sym->right = NULL; sym->hash = hash_symbol(str, len); memcpy(jl_symbol_name(sym), str, len); jl_symbol_name(sym)[len] = 0; return sym; }
// get binding for adding a method // like jl_get_binding_wr, but has different error paths JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var) { jl_binding_t **bp = _jl_get_module_binding_bp(m, var); jl_binding_t *b = *bp; if (b != HT_NOTFOUND) { if (b->owner != m) { if (b->owner == NULL) { b->owner = m; } else { jl_binding_t *b2 = jl_get_binding(b->owner, var); if (b2 == NULL || b2->value == NULL) jl_errorf("invalid method definition: imported function %s.%s does not exist", jl_symbol_name(b->owner->name), jl_symbol_name(var)); // TODO: we might want to require explicitly importing types to add constructors if (!b->imported && !jl_is_type(b2->value)) { jl_errorf("error in method definition: function %s.%s must be explicitly imported to be extended", jl_symbol_name(b->owner->name), jl_symbol_name(var)); } return b2; } } return b; } b = new_binding(var); b->owner = m; *bp = b; jl_gc_wb_buf(m, b, sizeof(jl_binding_t)); return *bp; }
static jl_sym_t *mk_symbol(const char *str, size_t len) { #ifndef MEMDEBUG static char *sym_pool = NULL; static char *pool_ptr = NULL; #endif jl_sym_t *sym; size_t nb = symbol_nbytes(len); if (nb >= SYM_POOL_SIZE) { jl_exceptionf(jl_argumenterror_type, "Symbol length exceeds maximum length"); } #ifdef MEMDEBUG sym = (jl_sym_t*)jl_valueof(malloc(nb)); #else if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) { sym_pool = (char*)malloc(SYM_POOL_SIZE); pool_ptr = sym_pool; } sym = (jl_sym_t*)jl_valueof(pool_ptr); pool_ptr += nb; #endif jl_set_typeof(sym, jl_sym_type); sym->left = sym->right = NULL; sym->hash = hash_symbol(str, len); memcpy(jl_symbol_name(sym), str, len); jl_symbol_name(sym)[len] = 0; return sym; }
static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str, size_t len, jl_sym_t *volatile **slot) { jl_sym_t *node = jl_atomic_load_acquire(ptree); uintptr_t h = hash_symbol(str, len); // Tree nodes sorted by major key of (int(hash)) and minor key of (str). while (node != NULL) { intptr_t x = (intptr_t)(h - node->hash); if (x == 0) { x = strncmp(str, jl_symbol_name(node), len); if (x == 0 && jl_symbol_name(node)[len] == 0) { if (slot != NULL) *slot = ptree; return node; } } if (x < 0) ptree = &node->left; else ptree = &node->right; node = jl_atomic_load_acquire(ptree); } if (slot != NULL) *slot = ptree; return node; }
JL_DLLEXPORT int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err) { jl_svec_t *fn = t->name->names; for(size_t i=0; i < jl_svec_len(fn); i++) { if (jl_svecref(fn,i) == (jl_value_t*)fld) { return (int)i; } } if (err) jl_errorf("type %s has no field %s", jl_symbol_name(t->name->name), jl_symbol_name(fld)); return -1; }
// get binding for reading. might return NULL for unbound. static jl_binding_t *jl_get_binding_(jl_module_t *m, jl_sym_t *var, modstack_t *st) { modstack_t top = { m, st }; modstack_t *tmp = st; while (tmp != NULL) { if (tmp->m == m) { // import cycle without finding actual location return NULL; } tmp = tmp->prev; } jl_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, var); if (b == HT_NOTFOUND || b->owner == NULL) { jl_module_t *owner = NULL; for(int i=(int)m->usings.len-1; i >= 0; --i) { jl_module_t *imp = (jl_module_t*)m->usings.items[i]; jl_binding_t *tempb = (jl_binding_t*)ptrhash_get(&imp->bindings, var); if (tempb != HT_NOTFOUND && tempb->exportp) { tempb = jl_get_binding_(imp, var, &top); if (tempb == NULL || tempb->owner == NULL) // couldn't resolve; try next using (see issue #6105) continue; if (owner != NULL && tempb->owner != b->owner && !(tempb->constp && tempb->value && b->constp && b->value == tempb->value)) { jl_printf(JL_STDERR, "WARNING: both %s and %s export \"%s\"; uses of it in module %s must be qualified\n", jl_symbol_name(owner->name), jl_symbol_name(imp->name), jl_symbol_name(var), jl_symbol_name(m->name)); // mark this binding resolved, to avoid repeating the warning (void)jl_get_binding_wr(m, var); return NULL; } owner = imp; b = tempb; } } if (owner != NULL) { // do a full import to prevent the result of this lookup // from changing, for example if this var is assigned to // later. module_import_(m, b->owner, var, 0); return b; } return NULL; } if (b->owner != m) return jl_get_binding_(b->owner, var, &top); return b; }
static jl_sym_t *mk_symbol(const char *str, size_t len) { jl_sym_t *sym; size_t nb = symbol_nbytes(len); jl_taggedvalue_t *tag = (jl_taggedvalue_t*)jl_gc_perm_alloc_nolock(nb); sym = (jl_sym_t*)jl_valueof(tag); // set to old marked since we don't need write barrier on it. tag->header = ((uintptr_t)jl_sym_type) | GC_OLD_MARKED; sym->left = sym->right = NULL; sym->hash = hash_symbol(str, len); memcpy(jl_symbol_name(sym), str, len); jl_symbol_name(sym)[len] = 0; return sym; }
// get binding for assignment JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var) { jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var); jl_binding_t *b; if (*bp != HT_NOTFOUND) { if ((*bp)->owner == NULL) { (*bp)->owner = m; return *bp; } else if ((*bp)->owner != m) { // TODO: change this to an error soon jl_printf(JL_STDERR, "WARNING: imported binding for %s overwritten in module %s\n", jl_symbol_name(var), jl_symbol_name(m->name)); } else { return *bp; } } b = new_binding(var); b->owner = m; *bp = b; jl_gc_wb_buf(m, b); return *bp; }
// get kwsorter field, with appropriate error check and message JL_DLLEXPORT jl_value_t *jl_get_keyword_sorter(jl_value_t *f) { jl_methtable_t *mt = jl_gf_mtable(f); if (mt->kwsorter == NULL) jl_errorf("function %s does not accept keyword arguments", jl_symbol_name(mt->name)); return mt->kwsorter; }
JL_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", jl_symbol_name(b->name)); } jl_printf(JL_STDERR, "WARNING: redefining constant %s\n", jl_symbol_name(b->name)); } } b->value = rhs; jl_gc_wb_binding(b, rhs); }
JL_DLLEXPORT jl_value_t *jl_cglobal(jl_value_t *v, jl_value_t *ty) { JL_TYPECHK(cglobal, type, ty); jl_value_t *rt = v == (jl_value_t*)jl_void_type ? (jl_value_t*)jl_voidpointer_type : // a common case (jl_value_t*)jl_apply_type_((jl_value_t*)jl_pointer_type, &ty, 1); if (!jl_is_leaf_type(rt)) jl_error("cglobal: type argument not a leaftype"); if (jl_is_tuple(v) && jl_nfields(v) == 1) v = jl_fieldref(v, 0); if (jl_is_pointer(v)) return jl_reinterpret(rt, v); char *f_lib = NULL; if (jl_is_tuple(v) && jl_nfields(v) > 1) { jl_value_t *t1 = jl_fieldref(v, 1); v = jl_fieldref(v, 0); if (jl_is_symbol(t1)) f_lib = jl_symbol_name((jl_sym_t*)t1); else if (jl_is_string(t1)) f_lib = jl_string_data(t1); else JL_TYPECHK(cglobal, symbol, t1) }
JL_DLLEXPORT jl_value_t *jl_cglobal(jl_value_t *v, jl_value_t *ty) { JL_TYPECHK(cglobal, type, ty); JL_GC_PUSH1(&v); jl_value_t *rt = ty == (jl_value_t*)jl_void_type ? (jl_value_t*)jl_voidpointer_type : // a common case (jl_value_t*)jl_apply_type1((jl_value_t*)jl_pointer_type, ty); JL_GC_PROMISE_ROOTED(rt); // (JL_ALWAYS_LEAFTYPE) if (!jl_is_concrete_type(rt)) jl_error("cglobal: type argument not concrete"); if (jl_is_tuple(v) && jl_nfields(v) == 1) v = jl_fieldref(v, 0); if (jl_is_pointer(v)) { v = jl_bitcast(rt, v); JL_GC_POP(); return v; } char *f_lib = NULL; if (jl_is_tuple(v) && jl_nfields(v) > 1) { jl_value_t *t1 = jl_fieldref_noalloc(v, 1); v = jl_fieldref(v, 0); if (jl_is_symbol(t1)) f_lib = jl_symbol_name((jl_sym_t*)t1); else if (jl_is_string(t1)) f_lib = jl_string_data(t1); else JL_TYPECHK(cglobal, symbol, t1) }
JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b) { if (b->value != NULL && !b->constp) { jl_errorf("cannot declare %s constant; it already has a value", jl_symbol_name(b->name)); } b->constp = 1; }
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; }
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; }
// copy a :lambda Expr into its LambdaInfo representation static void jl_lambda_info_set_ast(jl_lambda_info_t *li, jl_expr_t *ast) { assert(jl_is_expr(ast)); jl_expr_t *bodyex = (jl_expr_t*)jl_exprarg(ast, 2); assert(jl_is_expr(bodyex)); jl_array_t *body = bodyex->args; li->code = (jl_value_t*)body; jl_gc_wb(li, li->code); if (has_meta(body, pure_sym)) li->pure = 1; jl_array_t *vinfo = (jl_array_t*)jl_exprarg(ast, 1); jl_array_t *vis = (jl_array_t*)jl_array_ptr_ref(vinfo, 0); size_t nslots = jl_array_len(vis); jl_value_t *ssavalue_types = jl_array_ptr_ref(vinfo, 2); assert(jl_is_long(ssavalue_types)); size_t nssavalue = jl_unbox_long(ssavalue_types); li->slotnames = jl_alloc_vec_any(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_array_ptr_ref(vis, i); jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(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_array_ptr_set(li->slotnames, i, name); jl_array_uint8_set(li->slotflags, i, jl_unbox_long(jl_array_ptr_ref(vi, 2))); } jl_array_t *sparams = (jl_array_t*)jl_array_ptr_ref(vinfo, 3); assert(jl_is_array(sparams)); li->sparam_syms = jl_alloc_svec_uninit(jl_array_len(sparams)); jl_gc_wb(li, li->sparam_syms); for(i=0; i < jl_array_len(sparams); i++) { jl_svecset(li->sparam_syms, i, jl_array_ptr_ref(sparams, i)); } jl_array_t *args = (jl_array_t*)jl_exprarg(ast, 0); size_t narg = jl_array_len(args); li->nargs = narg; li->isva = narg > 0 && jl_is_rest_arg(jl_array_ptr_ref(args, narg - 1)); }
void jl_binding_deprecation_warning(jl_binding_t *b) { if (b->deprecated && jl_options.depwarn) { if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR) jl_printf(JL_STDERR, "WARNING: "); if (b->owner) jl_printf(JL_STDERR, "%s.%s is deprecated", jl_symbol_name(b->owner->name), jl_symbol_name(b->name)); else jl_printf(JL_STDERR, "%s is deprecated", jl_symbol_name(b->name)); jl_value_t *v = b->value; if (v && (jl_is_type(v)/* || (jl_is_function(v) && jl_is_gf(v))*/)) { jl_printf(JL_STDERR, ", use "); jl_static_show(JL_STDERR, v); jl_printf(JL_STDERR, " instead"); } jl_printf(JL_STDERR, ".\n"); if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR) jl_printf(JL_STDERR, " likely near %s:%d\n", jl_filename, jl_lineno); if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR) { if (b->owner) jl_errorf("deprecated binding: %s.%s", jl_symbol_name(b->owner->name), jl_symbol_name(b->name)); else jl_errorf("deprecated binding: %s", jl_symbol_name(b->name)); } } }
jl_sym_t *jl_demangle_typename(jl_sym_t *s) { char *n = jl_symbol_name(s); if (n[0] != '#') return s; char *end = strrchr(n, '#'); int32_t len; if (end == n || end == n+1) len = strlen(n) - 1; else len = (end-n) - 1; return jl_symbol_n(&n[1], len); }
// get binding for adding a method // like jl_get_binding_wr, but uses existing imports instead of warning // and overwriting. JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var) { if (jl_base_module && m->std_imports && !jl_binding_resolved_p(m,var)) { jl_module_t *opmod = (jl_module_t*)jl_get_global(jl_base_module, jl_symbol("Operators")); if (opmod != NULL && jl_defines_or_exports_p(opmod, var)) { jl_printf(JL_STDERR, "WARNING: module %s should explicitly import %s from %s\n", jl_symbol_name(m->name), jl_symbol_name(var), jl_symbol_name(jl_base_module->name)); jl_module_import(m, opmod, var); } } jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var); jl_binding_t *b = *bp; if (b != HT_NOTFOUND) { if (b->owner != m && b->owner != NULL) { jl_binding_t *b2 = jl_get_binding(b->owner, var); if (b2 == NULL) jl_errorf("invalid method definition: imported function %s.%s does not exist", jl_symbol_name(b->owner->name), jl_symbol_name(var)); if (!b->imported && (b2->value==NULL || jl_is_function(b2->value))) { if (b2->value && !jl_is_gf(b2->value)) { jl_errorf("error in method definition: %s.%s cannot be extended", jl_symbol_name(b->owner->name), jl_symbol_name(var)); } else { if (jl_base_module && m->std_imports && b->owner == jl_base_module) { jl_module_t *opmod = (jl_module_t*)jl_get_global(jl_base_module, jl_symbol("Operators")); if (opmod != NULL && jl_defines_or_exports_p(opmod, var)) { jl_printf(JL_STDERR, "WARNING: module %s should explicitly import %s from %s\n", jl_symbol_name(m->name), jl_symbol_name(var), jl_symbol_name(b->owner->name)); return b2; } } jl_errorf("error in method definition: function %s.%s must be explicitly imported to be extended", jl_symbol_name(b->owner->name), jl_symbol_name(var)); } } return b2; } b->owner = m; return b; } b = new_binding(var); b->owner = m; *bp = b; jl_gc_wb_buf(m, b); return *bp; }
static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v) { if (jl_is_symbol(v)) return symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v)); if (v == jl_true) return jl_ast_ctx(fl_ctx)->true_sym; if (v == jl_false) return jl_ast_ctx(fl_ctx)->false_sym; if (v == jl_nothing) return fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->null_sym, fl_ctx->NIL); if (jl_is_expr(v)) { jl_expr_t *ex = (jl_expr_t*)v; value_t args = fl_ctx->NIL; fl_gc_handle(fl_ctx, &args); array_to_list(fl_ctx, ex->args, &args); value_t hd = julia_to_scm_(fl_ctx, (jl_value_t*)ex->head); if (ex->head == lambda_sym && jl_expr_nargs(ex)>0 && jl_is_array(jl_exprarg(ex,0))) { value_t llist = fl_ctx->NIL; fl_gc_handle(fl_ctx, &llist); array_to_list(fl_ctx, (jl_array_t*)jl_exprarg(ex,0), &llist); car_(args) = llist; fl_free_gc_handles(fl_ctx, 1); } value_t scmv = fl_cons(fl_ctx, hd, args); fl_free_gc_handles(fl_ctx, 1); return scmv; } // GC Note: jl_fieldref(v, 0) allocate for LabelNode, GotoNode // but we don't need a GC root here because julia_to_list2 // shouldn't allocate in this case. if (jl_typeis(v, jl_labelnode_type)) return julia_to_list2(fl_ctx, (jl_value_t*)label_sym, jl_fieldref(v,0)); if (jl_typeis(v, jl_linenumbernode_type)) return julia_to_list2(fl_ctx, (jl_value_t*)line_sym, jl_fieldref(v,0)); if (jl_typeis(v, jl_gotonode_type)) return julia_to_list2(fl_ctx, (jl_value_t*)goto_sym, jl_fieldref(v,0)); if (jl_typeis(v, jl_quotenode_type)) return julia_to_list2(fl_ctx, (jl_value_t*)inert_sym, jl_fieldref(v,0)); if (jl_typeis(v, jl_newvarnode_type)) return julia_to_list2(fl_ctx, (jl_value_t*)newvar_sym, jl_fieldref(v,0)); if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v))) return fixnum(jl_unbox_long(v)); if (jl_is_ssavalue(v)) jl_error("SSAValue objects should not occur in an AST"); if (jl_is_slot(v)) jl_error("Slot objects should not occur in an AST"); value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*)); *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = v; return opaque; }
void jl_set_datatype_super(jl_datatype_t *tt, jl_value_t *super) { if (!jl_is_datatype(super) || !jl_is_abstracttype(super) || tt->name == ((jl_datatype_t*)super)->name || jl_subtype(super,(jl_value_t*)jl_vararg_type,0) || jl_is_tuple_type(super) || jl_subtype(super,(jl_value_t*)jl_type_type,0) || super == (jl_value_t*)jl_builtin_type) { jl_errorf("invalid subtyping in definition of %s", jl_symbol_name(tt->name->name)); } tt->super = (jl_datatype_t*)super; jl_gc_wb(tt, tt->super); }
// get binding for assignment JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var, int error) { jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var); jl_binding_t *b = *bp; if (b != HT_NOTFOUND) { if (b->owner != m) { if (b->owner == NULL) { b->owner = m; } else if (error) { jl_errorf("cannot assign variable %s.%s from module %s", jl_symbol_name(b->owner->name), jl_symbol_name(var), jl_symbol_name(m->name)); } } return *bp; } b = new_binding(var); b->owner = m; *bp = b; jl_gc_wb_buf(m, b, sizeof(jl_binding_t)); return *bp; }
JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type) { jl_value_t *ftype = (jl_value_t*)jl_first_argument_datatype(type); if (ftype == NULL) return jl_static_show(s, type); size_t n = 0; if (jl_nparams(ftype)==0 || ftype == ((jl_datatype_t*)ftype)->name->wrapper) { n += jl_printf(s, "%s", jl_symbol_name(((jl_datatype_t*)ftype)->name->mt->name)); } else { n += jl_printf(s, "(::"); n += jl_static_show(s, ftype); n += jl_printf(s, ")"); } // TODO: better way to show method parameters type = jl_unwrap_unionall(type); if (!jl_is_datatype(type)) { n += jl_printf(s, " "); n += jl_static_show(s, type); return n; } size_t tl = jl_nparams(type); n += jl_printf(s, "("); size_t i; for (i = 1; i < tl; i++) { jl_value_t *tp = jl_tparam(type, i); if (i != tl - 1) { n += jl_static_show(s, tp); n += jl_printf(s, ", "); } else { if (jl_is_vararg_type(tp)) { n += jl_static_show(s, jl_unwrap_vararg(tp)); n += jl_printf(s, "..."); } else { n += jl_static_show(s, tp); } } } n += jl_printf(s, ")"); return n; }
void jl_binding_deprecation_warning(jl_binding_t *b) { if (b->deprecated && jl_options.depwarn) { if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR) jl_printf(JL_STDERR, "WARNING: "); if (b->owner) jl_printf(JL_STDERR, "%s.%s is deprecated", jl_symbol_name(b->owner->name), jl_symbol_name(b->name)); else jl_printf(JL_STDERR, "%s is deprecated", jl_symbol_name(b->name)); jl_value_t *v = b->value; if (v && (jl_is_type(v) || (jl_is_function(v) && jl_is_gf(v)))) { jl_printf(JL_STDERR, ", use "); if (b->owner && strcmp(jl_symbol_name(b->owner->name), "Base") == 0 && strcmp(jl_symbol_name(b->name), "Uint") == 0) { // TODO: Suggesting type b->value is wrong for typealiases. // Uncommon in Base, hardcoded here for now, see #13221 jl_printf(JL_STDERR, "UInt"); } else { jl_static_show(JL_STDERR, v); } jl_printf(JL_STDERR, " instead"); } jl_printf(JL_STDERR, ".\n"); if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR) jl_printf(JL_STDERR, " likely near %s:%d\n", jl_filename, jl_lineno); if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR) { if (b->owner) jl_errorf("deprecated binding: %s.%s", jl_symbol_name(b->owner->name), jl_symbol_name(b->name)); else jl_errorf("deprecated binding: %s", jl_symbol_name(b->name)); } } }
JL_DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported) { jl_array_t *a = jl_alloc_array_1d(jl_array_symbol_type, 0); JL_GC_PUSH1(&a); size_t i; void **table = m->bindings.table; for (i = 1; i < m->bindings.size; i+=2) { if (table[i] != HT_NOTFOUND) { jl_binding_t *b = (jl_binding_t*)table[i]; int hidden = jl_symbol_name(b->name)[0]=='#'; if ((b->exportp || ((imported || b->owner == m) && (all || m == jl_main_module))) && (all || (!b->deprecated && !hidden))) { jl_array_grow_end(a, 1); //XXX: change to jl_arrayset if array storage allocation for Array{Symbols,1} changes: jl_array_ptr_set(a, jl_array_dim0(a)-1, (jl_value_t*)b->name); } } } JL_GC_POP(); return (jl_value_t*)a; }
// NOTE: we use explici since explicit is a C++ keyword static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s, int explici) { if (to == from) return; jl_binding_t *b = jl_get_binding(from, s); if (b == NULL) { jl_printf(JL_STDERR, "WARNING: could not import %s.%s into %s\n", jl_symbol_name(from->name), jl_symbol_name(s), jl_symbol_name(to->name)); } else { jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&to->bindings, s); jl_binding_t *bto = *bp; if (bto != HT_NOTFOUND) { if (bto == b) { // importing a binding on top of itself. harmless. } else if (bto->owner == b->owner) { // already imported bto->imported = (explici!=0); } else if (bto->owner != to && bto->owner != NULL) { // already imported from somewhere else jl_binding_t *bval = jl_get_binding(to, s); if (bval->constp && bval->value && b->constp && b->value == bval->value) { // equivalent binding bto->imported = (explici!=0); return; } jl_printf(JL_STDERR, "WARNING: ignoring conflicting import of %s.%s into %s\n", jl_symbol_name(from->name), jl_symbol_name(s), jl_symbol_name(to->name)); } else if (bto->constp || bto->value) { // conflict with name owned by destination module assert(bto->owner == to); if (bto->constp && bto->value && b->constp && b->value == bto->value) { // equivalent binding return; } jl_printf(JL_STDERR, "WARNING: import of %s.%s into %s conflicts with an existing identifier; ignored.\n", jl_symbol_name(from->name), jl_symbol_name(s), jl_symbol_name(to->name)); } else { bto->owner = b->owner; bto->imported = (explici!=0); } } else { jl_binding_t *nb = new_binding(s); nb->owner = b->owner; nb->imported = (explici!=0); nb->deprecated = b->deprecated; *bp = nb; jl_gc_wb_buf(to, nb); } } }
static void check_can_assign_type(jl_binding_t *b) { if (b->constp && b->value != NULL && !jl_is_datatype(b->value)) jl_errorf("invalid redefinition of constant %s", jl_symbol_name(b->name)); }
// get the name of a type as a string JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v) { if (!jl_is_datatype(v)) return NULL; return jl_symbol_name(((jl_datatype_t*)v)->name->name); }
JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super, jl_svec_t *parameters, jl_svec_t *fnames, jl_svec_t *ftypes, int abstract, int mutabl, int ninitialized) { jl_datatype_t *t=NULL; jl_typename_t *tn=NULL; JL_GC_PUSH2(&t, &tn); if (!jl_boot_file_loaded && jl_is_symbol(name)) { // hack to avoid making two versions of basic types needed // during bootstrapping if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int32")) t = jl_int32_type; else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int64")) t = jl_int64_type; else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Bool")) t = jl_bool_type; else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "UInt8")) t = jl_uint8_type; } if (t == NULL) t = jl_new_uninitialized_datatype(jl_svec_len(fnames), 2); // TODO else tn = t->name; // init before possibly calling jl_new_typename t->super = super; if (super != NULL) jl_gc_wb(t, t->super); t->parameters = parameters; jl_gc_wb(t, t->parameters); t->types = ftypes; if (ftypes != NULL) jl_gc_wb(t, t->types); t->abstract = abstract; t->mutabl = mutabl; t->pointerfree = 0; t->ninitialized = ninitialized; t->instance = NULL; t->struct_decl = NULL; t->ditype = NULL; t->size = 0; t->alignment = 1; t->haspadding = 0; if (tn == NULL) { t->name = NULL; if (jl_is_typename(name)) { tn = (jl_typename_t*)name; } else { tn = jl_new_typename((jl_sym_t*)name); if (!abstract) { tn->mt = jl_new_method_table(name, jl_current_module); jl_gc_wb(tn, tn->mt); } } t->name = tn; jl_gc_wb(t, t->name); } t->name->names = fnames; jl_gc_wb(t->name, t->name->names); if (t->name->primary == NULL) { t->name->primary = (jl_value_t*)t; jl_gc_wb(t->name, t); } jl_precompute_memoized_dt(t); if (abstract || jl_svec_len(parameters) > 0) { t->uid = 0; } else { t->uid = jl_assign_type_uid(); if (t->types != NULL) jl_compute_field_offsets(t); } JL_GC_POP(); return t; }