自学教程：C++ HAlloc函数代码示例

BIF_RETTYPE bit_size_1(BIF_ALIST_1){    Uint low_bits;    Uint bytesize;    Uint high_bits;    if (is_binary(BIF_ARG_1)) {	bytesize = binary_size(BIF_ARG_1);	high_bits = bytesize >>  ((sizeof(Uint) * 8)-3);	low_bits = (bytesize << 3) + binary_bitsize(BIF_ARG_1);	if (high_bits == 0) {	    if (IS_USMALL(0,low_bits)) {		BIF_RET(make_small(low_bits));	    } else {		Eterm* hp = HAlloc(BIF_P, BIG_UINT_HEAP_SIZE);		BIF_RET(uint_to_big(low_bits, hp));	    }	} else {	    Uint sz = BIG_UINT_HEAP_SIZE+1;	    Eterm* hp = HAlloc(BIF_P, sz);	    hp[0] = make_pos_bignum_header(sz-1);	    BIG_DIGIT(hp,0) = low_bits;	    BIG_DIGIT(hp,1) = high_bits;	    BIF_RET(make_big(hp));	}    } else {

BIF_RETTYPEprepare_loading_2(BIF_ALIST_2){    byte* temp_alloc = NULL;    byte* code;    Uint sz;    Binary* magic;    Eterm reason;    Eterm* hp;    Eterm res;    if (is_not_atom(BIF_ARG_1)) {    error:	erts_free_aligned_binary_bytes(temp_alloc);	BIF_ERROR(BIF_P, BADARG);    }    if ((code = erts_get_aligned_binary_bytes(BIF_ARG_2, &temp_alloc)) == NULL) {	goto error;    }    magic = erts_alloc_loader_state();    sz = binary_size(BIF_ARG_2);    reason = erts_prepare_loading(magic, BIF_P, BIF_P->group_leader,				  &BIF_ARG_1, code, sz);    erts_free_aligned_binary_bytes(temp_alloc);    if (reason != NIL) {	hp = HAlloc(BIF_P, 3);	res = TUPLE2(hp, am_error, reason);	BIF_RET(res);    }    hp = HAlloc(BIF_P, PROC_BIN_SIZE);    res = erts_mk_magic_binary_term(&hp, &MSO(BIF_P), magic);    erts_refc_dec(&magic->refc, 1);    BIF_RET(res);}

static Eterm pd_hash_get_keys(Process *p, Eterm value) {    Eterm *hp;    Eterm res = NIL;    ProcDict *pd = p->dictionary;    unsigned int i, num;    Eterm tmp, tmp2;    if (pd == NULL) {	return res;    }    num = HASH_RANGE(pd);    for (i = 0; i < num; ++i) {	tmp = ARRAY_GET(pd, i);	if (is_boxed(tmp)) {	    ASSERT(is_tuple(tmp));	    if (EQ(tuple_val(tmp)[2], value)) {		hp = HAlloc(p, 2);		res = CONS(hp, tuple_val(tmp)[1], res);	    }	} else if (is_list(tmp)) {	    while (tmp != NIL) {		tmp2 = TCAR(tmp);		if (EQ(tuple_val(tmp2)[2], value)) {		    hp = HAlloc(p, 2);		    res = CONS(hp, tuple_val(tmp2)[1], res);		}		tmp = TCDR(tmp);	    }	}    }    return res;}

BIF_RETTYPE abs_1(BIF_ALIST_1){    Eterm res;    Sint i0, i;    Eterm* hp;    /* integer arguments */    if (is_small(BIF_ARG_1)) {	i0 = signed_val(BIF_ARG_1);	i = ERTS_SMALL_ABS(i0);	if (i0 == MIN_SMALL) {	    hp = HAlloc(BIF_P, BIG_UINT_HEAP_SIZE);	    BIF_RET(uint_to_big(i, hp));	} else {	    BIF_RET(make_small(i));	}    } else if (is_big(BIF_ARG_1)) {	if (!big_sign(BIF_ARG_1)) {	    BIF_RET(BIF_ARG_1);	} else {	    int sz = big_arity(BIF_ARG_1) + 1;	    Uint* x;	    hp = HAlloc(BIF_P, sz);	/* See note at beginning of file */	    sz--;	    res = make_big(hp);	    x = big_val(BIF_ARG_1);	    *hp++ = make_pos_bignum_header(sz);	    x++;                          /* skip thing */	    while(sz--)		*hp++ = *x++;	    BIF_RET(res);	}    } else if (is_float(BIF_ARG_1)) {	FloatDef f;	GET_DOUBLE(BIF_ARG_1, f);	if (f.fd < 0.0) {	    hp = HAlloc(BIF_P, FLOAT_SIZE_OBJECT);	    f.fd = fabs(f.fd);	    res = make_float(hp);	    PUT_DOUBLE(f, hp);	    BIF_RET(res);	}	else	    BIF_RET(BIF_ARG_1);    }    BIF_ERROR(BIF_P, BADARG);}

BIF_RETTYPE append_2(BIF_ALIST_2){    Eterm list;    Eterm copy;    Eterm last;    size_t need;    Eterm* hp;    int i;    if ((i = list_length(BIF_ARG_1)) < 0) {	BIF_ERROR(BIF_P, BADARG);    }    if (i == 0) {	BIF_RET(BIF_ARG_2);    } else if (is_nil(BIF_ARG_2)) {	BIF_RET(BIF_ARG_1);    }    need = 2*i;    hp = HAlloc(BIF_P, need);     list = BIF_ARG_1;    copy = last = CONS(hp, CAR(list_val(list)), make_list(hp+2));    list = CDR(list_val(list));    hp += 2;    i--;    while(i--) {	Eterm* listp = list_val(list);	last = CONS(hp, CAR(listp), make_list(hp+2));	list = CDR(listp);	hp += 2;    }    CDR(list_val(last)) = BIF_ARG_2;    BIF_RET(copy);}

BIF_RETTYPE float_1(BIF_ALIST_1){    Eterm res;    Eterm* hp;    FloatDef f;         /* check args */    if (is_not_integer(BIF_ARG_1)) {	if (is_float(BIF_ARG_1))  {	    BIF_RET(BIF_ARG_1);	} else {	badarg:	    BIF_ERROR(BIF_P, BADARG);	}    }    if (is_small(BIF_ARG_1)) {	Sint i = signed_val(BIF_ARG_1);	f.fd = i;		/* use "C"'s auto casting */    } else if (big_to_double(BIF_ARG_1, &f.fd) < 0) {	goto badarg;    }    hp = HAlloc(BIF_P, FLOAT_SIZE_OBJECT);    res = make_float(hp);    PUT_DOUBLE(f, hp);    BIF_RET(res);}

BIF_RETTYPE hipe_bifs_shared_gc_info_0(BIF_ALIST_0){#ifdef __BENCHMARK__#if !(defined(BM_COUNTERS))    Uint minor_global_gc = 0;    Uint major_global_gc = 0;#endif#ifndef BM_HEAP_SIZES    Uint max_used_global_heap	   = 0;    Uint max_allocated_global_heap = 0;#endif    Eterm *hp;    Uint tmp_used_heap = 0;    Uint tmp_allocated_heap = 0;    hp = HAlloc(BIF_P, 7);    BIF_RET(TUPLE6(hp,		   make_small((uint)minor_global_gc),		   make_small((uint)major_global_gc),		   make_small(tmp_used_heap),		   make_small(tmp_allocated_heap),		   make_small(max_used_global_heap),		   make_small(max_allocated_global_heap)));#else    BIF_RET(am_false);#endif}

Eterm reverse_1(ErlProcess* p, Eterm* reg, UInt live) {	UInt n = 0;	Eterm list = reg[0];	//debug("lists:reverse/1/n");	//debug_term(list);	//debug("/n");	while(is_list(list)) {		n++;		list = CDR(list_val(list));	}	Eterm* hp = HAlloc(p, 2*n, live);	Eterm result = NIL;	list = reg[0];	while(is_list(list)) {		Eterm* pair = list_val(list);		result = CONS(hp, CAR(pair), result);		list = CDR(pair);		hp += 2;	}	return result;}

Etermerts_preloaded(Process* p){    Eterm previous;    int j;    int need;    Eterm mod;    Eterm* hp;    char* name;    const Preload *preload = sys_preloaded();    j = 0;    while (preload[j].name != NULL) {	j++;    }    previous = NIL;    need = 2*j;    hp = HAlloc(p, need);    j = 0;    while ((name = preload[j].name) != NULL)  {	mod = am_atom_put(name, sys_strlen(name));	previous = CONS(hp, mod, previous);	hp += 2;	j++;    }    return previous;}

BIF_RETTYPE loaded_0(BIF_ALIST_0){    ErtsCodeIndex code_ix = erts_active_code_ix();    Module* modp;    Eterm previous = NIL;    Eterm* hp;    int i;    int j = 0;    for (i = 0; i < module_code_size(code_ix); i++) {	if ((modp = module_code(i, code_ix)) != NULL &&	    ((modp->curr.code_length != 0) ||	     (modp->old.code_length != 0))) {	    j++;	}    }    if (j > 0) {	hp = HAlloc(BIF_P, j*2);	for (i = 0; i < module_code_size(code_ix); i++) {	    if ((modp=module_code(i,code_ix)) != NULL &&		((modp->curr.code_length != 0) ||		 (modp->old.code_length != 0))) {		previous = CONS(hp, make_atom(modp->module), previous);		hp += 2;	    }	}    }    BIF_RET(previous);}

BIF_RETTYPE port_get_data_1(BIF_ALIST_1){    /*     * This is not a signal. See comment above.     */    Eterm res;    erts_aint_t data;    Port* prt;    prt = data_lookup_port(BIF_P, BIF_ARG_1);    if (!prt)        BIF_ERROR(BIF_P, BADARG);    data = erts_smp_atomic_read_ddrb(&prt->data);    if (data == (erts_aint_t)NULL)        BIF_ERROR(BIF_P, BADARG);  /* Port terminated by racing thread */    if ((data & 0x3) != 0) {	res = (Eterm) (UWord) data;	ASSERT(is_immed(res));    }    else {	ErtsPortDataHeap *pdhp = (ErtsPortDataHeap *) data;	Eterm *hp = HAlloc(BIF_P, pdhp->hsize);	res = copy_struct(pdhp->data, pdhp->hsize, &hp, &MSO(BIF_P));    }    BIF_RET(res);}

BIF_RETTYPE loaded_0(BIF_ALIST_0){    Eterm previous = NIL;    Eterm* hp;    int i;    int j = 0;        for (i = 0; i < module_code_size(); i++) {	if (module_code(i) != NULL &&	    ((module_code(i)->code_length != 0) ||	     (module_code(i)->old_code_length != 0))) {	    j++;	}    }    if (j > 0) {	hp = HAlloc(BIF_P, j*2);	for (i = 0; i < module_code_size(); i++) {	    if (module_code(i) != NULL &&		((module_code(i)->code_length != 0) ||		 (module_code(i)->old_code_length != 0))) {		previous = CONS(hp, make_atom(module_code(i)->module), 				previous);		hp += 2;	    }	}    }    BIF_RET(previous);}

BIF_RETTYPE hipe_bifs_message_info_0(BIF_ALIST_0){#ifdef __BENCHMARK__    Eterm *hp;#ifndef BM_COUNTERS    unsigned long messages_sent	  = 0;    unsigned long messages_copied = 0;    unsigned long messages_ego	  = 0;#endif#ifndef BM_MESSAGE_SIZES    unsigned long words_sent   = 0;    unsigned long words_copied = 0;    unsigned long words_prealloc = 0;#endif    hp = HAlloc(BIF_P, 7);    BIF_RET(TUPLE6(hp,		   make_small(messages_sent),		   make_small(messages_copied),		   make_small(messages_ego),		   make_small(words_sent),		   make_small(words_copied),		   make_small(words_prealloc)));#else    BIF_RET(am_false);#endif}

static int http_request_erl(void* arg, const http_atom_t* meth,                            const char* meth_ptr, int meth_len,                            const PacketHttpURI* uri, int major, int minor){    struct packet_callback_args* pca = (struct packet_callback_args*) arg;        Eterm meth_term, uri_term, ver_term;    Uint sz = 0;    Uint* szp = &sz;    Eterm* hp;    Eterm** hpp = NULL;    /* {http_request,Meth,Uri,Version} */    for (;;) {        meth_term = (meth!=NULL) ? meth->atom :	    http_bld_string(pca, hpp, szp, meth_ptr, meth_len);        uri_term = http_bld_uri(pca, hpp, szp, uri);        ver_term = erts_bld_tuple(hpp, szp, 2,                                  make_small(major), make_small(minor));        pca->res = erts_bld_tuple(hpp, szp, 4, am_http_request, meth_term,                                  uri_term, ver_term);         if (hpp != NULL) break;        hpp = &hp;        hp = HAlloc(pca->p, sz);        szp = NULL;            }    return 1;}

BIF_RETTYPE hipe_bifs_gc_info_0(BIF_ALIST_0){#ifdef __BENCHMARK__#ifndef BM_COUNTERS    Uint minor_gc = 0;    Uint major_gc = 0;#endif#ifndef BM_HEAP_SIZES    Uint max_used_heap	    = 0;    Uint max_allocated_heap = 0;#endif    Eterm *hp;    Uint used_heap = (BIF_P->htop - BIF_P->heap) +		     (OLD_HTOP(BIF_P) - OLD_HEAP(BIF_P)) +		     MBUF_SIZE(BIF_P);    Uint alloc_heap = (BIF_P->hend - BIF_P->heap) +		      (OLD_HEND(BIF_P) - OLD_HEAP(BIF_P)) +		      MBUF_SIZE(BIF_P);    hp = HAlloc(BIF_P, 7);    BIF_RET(TUPLE6(hp,		   make_small((Uint)minor_gc),		   make_small((Uint)major_gc),		   make_small((Uint)used_heap),		   make_small((Uint)alloc_heap),		   make_small(max_used_heap),		   make_small(max_allocated_heap)));#else    BIF_RET(am_false);#endif}

static Etermmath_call_1(Process* p, double (*func)(double), Eterm arg1){    FloatDef a1;    Eterm res;    Eterm* hp;    ERTS_FP_CHECK_INIT(p);    if (is_float(arg1)) {	GET_DOUBLE(arg1, a1);    } else if (is_small(arg1)) {	a1.fd = signed_val(arg1);    } else if (is_big(arg1)) {	if (big_to_double(arg1, &a1.fd) < 0) {	badarith:	    p->freason = BADARITH;	    return THE_NON_VALUE;	}    } else {	p->freason = BADARG;	return THE_NON_VALUE;    }    a1.fd = (*func)(a1.fd);    ERTS_FP_ERROR_THOROUGH(p, a1.fd, goto badarith);    hp = HAlloc(p, FLOAT_SIZE_OBJECT);    res = make_float(hp);    PUT_DOUBLE(a1, hp);    return res;}

Eterm hipe_build_stacktrace(Process *p, struct StackTrace *s){    int depth, i;    Uint heap_size;    Eterm *hp, *hp_end, mfa, m, f, head, *next_p, next;    const void *ra;    unsigned int a;    depth = s->depth;    if (depth < 1)	return NIL;    heap_size = 6 * depth;	/* each [{M,F,A}|_] is 2+4 == 6 words */    hp = HAlloc(p, heap_size);    hp_end = hp + heap_size;    head = NIL;    next_p = &head;    for (i = 0; i < depth; ++i) {	ra = (const void*)s->trace[i];	if (!hipe_find_mfa_from_ra(ra, &m, &f, &a))	    continue;	mfa = TUPLE3(hp, m, f, make_small(a));	hp += 4;	next = CONS(hp, mfa, NIL);	*next_p = next;	next_p = &CDR(list_val(next));	hp += 2;    }    HRelease(p, hp_end, hp);    return head;}

static Etermpd_hash_get_all(Process *p, ProcDict *pd){    Eterm* hp;    Eterm res = NIL;    Eterm tmp, tmp2;    unsigned int i;    unsigned int num;    if (pd == NULL) {	return res;    }    num = HASH_RANGE(pd);    hp = HAlloc(p, pd->numElements * 2);        for (i = 0; i < num; ++i) {	tmp = ARRAY_GET(pd, i);	if (is_boxed(tmp)) {	    ASSERT(is_tuple(tmp));	    res = CONS(hp, tmp, res);	    hp += 2;	} else if (is_list(tmp)) {	    while (tmp != NIL) {		tmp2 = TCAR(tmp);		res = CONS(hp, tmp2, res);		hp += 2;		tmp = TCDR(tmp);	    }	}    }    return res;}

static Eterm load_nif_error(Process* p, const char* atom, const char* format, ...){    erts_dsprintf_buf_t* dsbufp = erts_create_tmp_dsbuf(0);    Eterm ret;    Eterm* hp;    Eterm** hpp = NULL;    Uint sz = 0;    Uint* szp = &sz;    va_list arglist;       va_start(arglist, format);    erts_vdsprintf(dsbufp, format, arglist);    va_end(arglist);        for (;;) {	Eterm txt = erts_bld_string_n(hpp, &sz, dsbufp->str, dsbufp->str_len);	ret = erts_bld_tuple(hpp, szp, 2, am_error,			     erts_bld_tuple(hpp, szp, 2, mkatom(atom), txt));	if (hpp != NULL) {	    break;	}	hp = HAlloc(p,sz);	hpp = &hp;	szp = NULL;    }    erts_destroy_tmp_dsbuf(dsbufp);    return ret;}

Etermerts_get_node_and_dist_references(struct process *proc){    Uint *hp;    Uint size;    Eterm res;#ifdef DEBUG    Uint *endp;#endif    erts_smp_proc_unlock(proc, ERTS_PROC_LOCK_MAIN);    erts_smp_block_system(0);    /* No need to lock any thing since we are alone... */    if (references_atoms_need_init) {	INIT_AM(heap);	INIT_AM(link);	INIT_AM(monitor);	INIT_AM(process);	INIT_AM(port);	INIT_AM(ets);	INIT_AM(binary);	INIT_AM(match_spec);	INIT_AM(control);	INIT_AM(dist);	INIT_AM(node);	INIT_AM(dist_references);	INIT_AM(node_references);	INIT_AM(timer);	INIT_AM(system);#ifdef HYBRID	INIT_AM(processes);#endif	references_atoms_need_init = 0;    }    setup_reference_table();    /* Get term size */    size = 0;    (void) reference_table_term(NULL, &size);    hp = HAlloc(proc, size);#ifdef DEBUG    ASSERT(size > 0);    endp = hp + size;#endif    /* Write term */    res = reference_table_term(&hp, NULL);    ASSERT(endp == hp);    delete_reference_table();    erts_smp_release_system();    erts_smp_proc_lock(proc, ERTS_PROC_LOCK_MAIN);    return res;}

static Eterm build_load_error(Process *p, int code){    int need = load_error_need(code);    Eterm *hp = NULL;    ERTS_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));    if (need) {	hp = HAlloc(p,need);    }    return build_load_error_hp(hp,code);}

static void os_getenv_foreach(Process *process, Eterm *result, Eterm key, Eterm value){    Eterm kvp_term, *hp;    hp = HAlloc(process, 5);    kvp_term = TUPLE2(hp, key, value);    hp += 3;    (*result) = CONS(hp, kvp_term, (*result));}

 /* return a timestamp */BIF_RETTYPE os_timestamp_0(BIF_ALIST_0){    Uint megasec, sec, microsec;    Eterm* hp;    get_sys_now(&megasec, &sec, &microsec);    hp = HAlloc(BIF_P, 4);    BIF_RET(TUPLE3(hp, make_small(megasec), make_small(sec),		   make_small(microsec)));}

static Etermalloc_trap_data(Process* c_p){    Binary* mbp = erts_create_magic_binary(sizeof(TrapData),                                           cleanup_trap_data);    Eterm* hp;    hp = HAlloc(c_p, ERTS_MAGIC_REF_THING_SIZE);    return erts_mk_magic_ref(&hp, &MSO(c_p), mbp);}

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));}

BIF_RETTYPE registered_0(BIF_ALIST_0){    int i;    Eterm res;    Uint need;    Eterm* hp;    HashBucket **bucket;#ifdef ERTS_SMP    ErtsProcLocks proc_locks = ERTS_PROC_LOCK_MAIN;    ERTS_SMP_CHK_HAVE_ONLY_MAIN_PROC_LOCK(BIF_P);    reg_safe_read_lock(BIF_P, &proc_locks);    if (!proc_locks)	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);#endif    bucket = process_reg.bucket;    /* work out how much heap we need & maybe garb, by scanning through       the registered process table */    need = 0;    for (i = 0; i < process_reg.size; i++) {	HashBucket *b = bucket[i];	while (b != NULL) {	    need += 2;	    b = b->next;	}    }    if (need == 0) {	reg_read_unlock();	BIF_RET(NIL);    }    hp = HAlloc(BIF_P, need);          /* scan through again and make the list */     res = NIL;    for (i = 0; i < process_reg.size; i++) {	HashBucket *b = bucket[i];	while (b != NULL) {	    RegProc *reg = (RegProc *) b;	    res = CONS(hp, reg->name, res);	    hp += 2;	    b = b->next;	}    }    reg_read_unlock();    BIF_RET(res);}

int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {    Uint i, ix;    bp_time_hash_t hash;    Uint size;    Eterm *hp, t;    bp_data_time_item_t *item = NULL;    BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));    if (bdt) {	if (retval) {	    /* collect all hashes to one hash */	    bp_hash_init(&hash, 64);	    /* foreach threadspecific hash */	    for (i = 0; i < bdt->n; i++) {		bp_data_time_item_t *sitem;	        /* foreach hash bucket not NIL*/		for(ix = 0; ix < bdt->hash[i].n; ix++) {		    item = &(bdt->hash[i].item[ix]);		    if (item->pid != NIL) {			sitem = bp_hash_get(&hash, item);			if (sitem) {			    BP_TIME_ADD(sitem, item);			} else {			    bp_hash_put(&hash, item);			}		    }		}	    }	    /* *retval should be NIL or term from previous bif in export entry */	    if (hash.used > 0) {		size = (5 + 2)*hash.used;		hp   = HAlloc(p, size);		for(ix = 0; ix < hash.n; ix++) {		    item = &(hash.item[ix]);		    if (item->pid != NIL) {			t = TUPLE4(hp, item->pid,				make_small(item->count),				make_small(item->s_time),				make_small(item->us_time));			hp += 5;			*retval = CONS(hp, t, *retval); hp += 2;		    }		}	    }	    bp_hash_delete(&hash);	}	return !0;    }    return 0;}

Etermos_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));}

Etermos_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);}

static ERTS_INLINE Etermunique_monotonic_integer_bif(Process *c_p, int positive){    Uint64 raw;    Uint hsz;    Eterm *hp;    raw = get_raw_unique_monotonic_integer();    hsz = get_unique_monotonic_integer_heap_size(raw, positive);    hp = hsz ? HAlloc(c_p, hsz) : NULL;    return make_unique_monotonic_integer_value(hp, hsz, raw, positive);}