BIF_RETTYPE os_getpid_0(BIF_ALIST_0) { char pid_string[21]; /* enough for a 64 bit number */ int n; Eterm* hp; sys_get_pid(pid_string, sizeof(pid_string)); /* In sys.c */ n = sys_strlen(pid_string); hp = HAlloc(BIF_P, n*2); BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL)); }
Eterm os_getenv_1(Process* p, Eterm key) { Eterm str; int len, res; char *key_str, *val; char buf[1024]; size_t val_size = sizeof(buf); len = is_string(key); if (!len) { BIF_ERROR(p, BADARG); } /* Leave at least one byte in buf for value */ key_str = len < sizeof(buf)-2 ? &buf[0] : erts_alloc(ERTS_ALC_T_TMP, len+1); if (intlist_to_buf(key, key_str, len) != len) erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__); key_str[len] = '\0'; if (key_str != &buf[0]) val = &buf[0]; else { val_size -= len + 1; val = &buf[len + 1]; } res = erts_sys_getenv(key_str, val, &val_size); if (res < 0) { no_var: str = am_false; } else { Eterm* hp; if (res > 0) { val = erts_alloc(ERTS_ALC_T_TMP, val_size); while (1) { res = erts_sys_getenv(key_str, val, &val_size); if (res == 0) break; else if (res < 0) goto no_var; else val = erts_realloc(ERTS_ALC_T_TMP, val, val_size); } } if (val_size) hp = HAlloc(p, val_size*2); str = buf_to_intlist(&hp, val, val_size, NIL); } if (key_str != &buf[0]) erts_free(ERTS_ALC_T_TMP, key_str); if (val < &buf[0] || &buf[sizeof(buf)-1] < val) erts_free(ERTS_ALC_T_TMP, val); BIF_RET(str); }
Eterm os_getpid_0(Process* p) { char pid_string[21]; /* enough for a 64 bit number */ int n; Eterm* hp; sys_get_pid(pid_string); /* In sys.c */ n = sys_strlen(pid_string); hp = HAlloc(p, n*2); BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL)); }
/* * Build a single {M,F,A,Loction} item to be part of * a stack trace. */ Eterm* erts_build_mfa_item(FunctionInfo* fi, Eterm* hp, Eterm args, Eterm* mfa_p) { BeamInstr* current = fi->current; Eterm loc = NIL; if (fi->loc != LINE_INVALID_LOCATION) { Eterm tuple; int line = LOC_LINE(fi->loc); int file = LOC_FILE(fi->loc); Eterm file_term = NIL; if (file == 0) { Atom* ap = atom_tab(atom_val(fi->current[0])); file_term = buf_to_intlist(&hp, ".erl", 4, NIL); file_term = buf_to_intlist(&hp, (char*)ap->name, ap->len, file_term); } else { Atom* ap = atom_tab(atom_val((fi->fname_ptr)[file-1])); file_term = buf_to_intlist(&hp, (char*)ap->name, ap->len, NIL); } tuple = TUPLE2(hp, am_line, make_small(line)); hp += 3; loc = CONS(hp, tuple, loc); hp += 2; tuple = TUPLE2(hp, am_file, file_term); hp += 3; loc = CONS(hp, tuple, loc); hp += 2; } if (is_list(args) || is_nil(args)) { *mfa_p = TUPLE4(hp, current[0], current[1], args, loc); } else { Eterm arity = make_small(current[2]); *mfa_p = TUPLE4(hp, current[0], current[1], arity, loc); } return hp + 5; }
/* * Return list of loaded drivers {ok,[string()]} */ BIF_RETTYPE erl_ddll_loaded_drivers_0(BIF_ALIST_0) { Eterm *hp; int need = 3; Eterm res = NIL; erts_driver_t *drv; lock_drv_list(); for (drv = driver_list; drv; drv = drv->next) { need += sys_strlen(drv->name)*2+2; } hp = HAlloc(BIF_P, need); for (drv = driver_list; drv; drv = drv->next) { Eterm l; l = buf_to_intlist(&hp, drv->name, sys_strlen(drv->name), NIL); res = CONS(hp,l,res); hp += 2; } res = TUPLE2(hp,am_ok,res); /* hp += 3 */ unlock_drv_list(); BIF_RET(res); }
Eterm os_getenv_0(Process* p) { GETENV_STATE state; char *cp; Eterm* hp; Eterm ret; Eterm str; int len; init_getenv_state(&state); ret = NIL; while ((cp = getenv_string(&state)) != NULL) { len = strlen(cp); hp = HAlloc(p, len*2+2); str = buf_to_intlist(&hp, cp, len, NIL); ret = CONS(hp, str, ret); } fini_getenv_state(&state); return ret; }
/* * Backend for erl_ddll:format_error, handles all "soft" errors returned by builtins, * possibly by calling the system specific error handler */ BIF_RETTYPE erl_ddll_format_error_int_1(BIF_ALIST_1) { Process *p = BIF_P; Eterm code_term = BIF_ARG_1; char *errstring = NULL; int errint; int len; Eterm ret = NIL; Eterm *hp; /* These errors can only appear in the erlang interface, not in the interface provided to drivers... */ switch (code_term) { case am_inconsistent: errstring = "Driver name and/or driver options are inconsistent with " "currently loaded driver"; break; case am_linked_in_driver: errstring = "Driver is statically linked and " "cannot be loaded/unloaded"; break; case am_permanent: errstring = "DDLL driver is permanent an can not be unloaded/loaded"; break; case am_not_loaded: errstring = "DDLL driver is not loaded"; break; case am_not_loaded_by_this_process: errstring = "DDLL driver was not loaded by this process"; break; case am_not_pending: errstring = "DDLL load not pending for this driver name"; break; case am_already_loaded: errstring = "DDLL driver is already loaded successfully"; break; case am_pending_reload: errstring = "Driver reloading is already pending"; break; case am_pending_process: errstring = "Driver is loaded by others when attempting " "option {reload, pending_driver}"; break; default: /* A "real" error, we translate the atom to a code and translate the code to a string in the same manner as in the interface provided to drivers... */ if (errdesc_to_code(code_term,&errint) != 0) { goto error; } lock_drv_list(); errstring = erts_ddll_error(errint); unlock_drv_list(); break; } if (errstring == NULL) { goto error; } len = sys_strlen(errstring); hp = HAlloc(p, 2 * len); ret = buf_to_intlist(&hp, errstring, len, NIL); BIF_RET(ret); error: BIF_ERROR(p,BADARG); }