ETERM *erl_mk_estring(const char *s, int len)
{
ETERM *ep;
int i;
if ((!s) || (len < 0)) return NULL;
/*
* ASSERT(s != NULL);
* ASSERT(len >= 0);
*/
ep = erl_mk_empty_list();
for (i = len-1; i >= 0; i--) {
ETERM* integer;
ETERM* cons;
integer = erl_alloc_eterm(ERL_INTEGER);
ERL_COUNT(integer) = 1;
ERL_INT_VALUE(integer) = (unsigned char)s[i];
cons = erl_alloc_eterm(ERL_LIST);
ERL_COUNT(cons) = 1;
HEAD(cons) = integer;
TAIL(cons) = ep;
ep = cons;
}
return ep;
}
/*
* Create any kind of reference.
*/
ETERM *__erl_mk_reference (ETERM* t,
const char *node,
size_t len,
unsigned int n[],
unsigned int creation)
{
if (t == NULL) {
if (node == NULL) return NULL;
t = erl_alloc_eterm(ERL_REF);
ERL_COUNT(t) = 1;
if (erl_atom_init_latin1(&t->uval.refval.node, node) == NULL)
{
erl_free_term(t);
erl_errno = ENOMEM;
return NULL;
}
}
ERL_REF_LEN(t) = len;
ERL_REF_NUMBERS(t)[0] = n[0] & 0x3ffff; /* 18 bits */
ERL_REF_NUMBERS(t)[1] = n[1];
ERL_REF_NUMBERS(t)[2] = n[2];
ERL_REF_CREATION(t) = creation; /* 32 bits */
return t;
}
ETERM *erl_mk_empty_list(void)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_EMPTY_LIST);
ERL_COUNT(ep) = 1;
return ep;
}
/*
* Create an INTEGER. Depending on its value it
* may end up as a BigNum.
*/
ETERM *erl_mk_int (int i)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_INTEGER);
ERL_COUNT(ep) = 1;
ERL_INT_VALUE(ep) = i;
return ep;
}
ETERM *erl_mk_ulonglong (unsigned long long i)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_U_LONGLONG);
ERL_COUNT(ep) = 1;
ERL_LL_UVALUE(ep) = i;
return ep;
}
ETERM *erl_mk_uint (unsigned int u)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_U_INTEGER);
ERL_COUNT(ep) = 1;
ERL_INT_UVALUE(ep) = u;
return ep;
}
/*
* Create a FLOAT.
*/
ETERM *erl_mk_float (double d)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_FLOAT);
ERL_COUNT(ep) = 1;
ERL_FLOAT_VALUE(ep) = d;
return ep;
}
ETERM *erl_mk_longlong (long long i)
{
ETERM *ep;
ep = erl_alloc_eterm(ERL_LONGLONG);
ERL_COUNT(ep) = 1;
ERL_LL_VALUE(ep) = i;
return ep;
}
/*
* Construct a new list by CONS'ing a HEAD on
* to the TAIL. Bump the reference counter on
* the head and tail object. Note that we allow
* non-well formed lists to be created.
*/
ETERM *erl_cons(ETERM *hd, ETERM *tl)
{
ETERM *ep;
if ((!hd) || (!tl)) return NULL;
/*
* ASSERT(hd != NULL);
* ASSERT(tl != NULL);
*/
ep = erl_alloc_eterm(ERL_LIST);
ERL_COUNT(ep) = 1;
HEAD(ep) = hd;
TAIL(ep) = tl;
ERL_COUNT(hd)++;
ERL_COUNT(tl)++;
return ep;
}
/*
* Create a TUPLE. For each element in the tuple
* bump its reference counter.
*/
ETERM *erl_mk_tuple (ETERM **arr,int size)
{
ETERM *ep;
int i;
if ((!arr) || (size < 0)) return NULL;
for (i=0; i<size; i++) if (!arr[i]) return NULL;
/* ASSERT(arr != NULL); */
ep = erl_alloc_eterm(ERL_TUPLE);
ERL_COUNT(ep) = 1;
ERL_TUPLE_SIZE(ep) = size;
ERL_TUPLE_ELEMS(ep) = (ETERM**) erl_malloc((size) * (sizeof(ETERM*)));
for (i = 0; i < size; i++) {
/* ASSERT(arr[i] != NULL); */
ERL_COUNT(arr[i])++;
ERL_TUPLE_ELEMENT(ep, i) = arr[i];
}
return ep;
}
/*
* Extract the HEAD of a LIST. Bump the reference
* counter on the head object.
*/
ETERM *erl_hd (const ETERM *ep)
{
if (!ep) return NULL;
/* ASSERT(ep != NULL); */
if (ERL_TYPE(ep) != ERL_LIST) {
return (ETERM *) NULL;
}
ERL_COUNT(ERL_CONS_HEAD(ep))++;
return ERL_CONS_HEAD(ep);
}
ETERM *erl_mk_list (ETERM **arr, int size)
{
ETERM *ep;
int i;
if ((!arr) || (size < 0)) return NULL;
for (i=0; i<size; i++) if (!arr[i]) return NULL;
/* ASSERT(arr != NULL); */
ep = erl_mk_empty_list();
if (size > 0) {
ERL_COUNT(ep)--;
}
for (i = size-1; i >= 0; i--) {
/* ASSERT(arr[i] != NULL); */
ep = erl_cons(arr[i], ep);
if (i > 0)
ERL_COUNT(ep)--; /* Internal reference */
}
return ep;
}
/*
* Create a BINARY.
*/
ETERM *erl_mk_binary (const char *b, int size)
{
ETERM *ep;
if ((!b) || (size < 0)) return NULL;
/* ASSERT(b != NULL); */
ep = erl_alloc_eterm(ERL_BINARY);
ERL_COUNT(ep) = 1;
ERL_BIN_SIZE(ep) = size;
ERL_BIN_PTR(ep) = (unsigned char *) erl_malloc(size);
memcpy(ERL_BIN_PTR(ep), b, size);
return ep;
}
/*
* Extract an ELEMENT from a TUPLE. Bump the
* reference counter on the extracted object.
*/
ETERM *erl_element (int ix, const ETERM *ep)
{
if ((!ep) || (ix < 0)) return NULL;
/*
* ASSERT(ep != NULL);
* ASSERT(ix >= 0);
*/
if ((ERL_TYPE(ep) == ERL_TUPLE) && (ix <= ERL_TUPLE_SIZE(ep))) {
ERL_COUNT(ERL_TUPLE_ELEMENT(ep, ix-1))++;
return ERL_TUPLE_ELEMENT(ep, ix-1);
}
else
return NULL;
} /* erl_element */
/*
* Extract the TAIL of a LIST. Bump the reference
* counter on the tail object.
*/
ETERM *erl_tl (const ETERM *ep)
{
ETERM *tl;
if (!ep) return NULL;
/* ASSERT(ep != NULL); */
if (ERL_TYPE(ep) != ERL_LIST) {
return (ETERM *) NULL;
}
tl = TAIL(ep);
ERL_COUNT(tl)++;
return tl;
}
/*
* Create an ATOM
*/
ETERM *erl_mk_atom (const char *s)
{
ETERM *ep;
/* ASSERT(s != NULL); */
if (!s) return NULL;
ep = erl_alloc_eterm(ERL_ATOM);
ERL_COUNT(ep) = 1;
if (erl_atom_init_latin1(&ep->uval.aval.d, s) == NULL) {
erl_free_term(ep);
erl_errno = ENOMEM;
return NULL;
}
return ep;
}
int erl_setelement (int ix, ETERM *ep, ETERM *vp)
{
if ((!ep) || (!vp)) return 0;
/* ASSERT(ep != NULL);
* ASSERT(vp != NULL);
*/
if ((ERL_TYPE(ep) == ERL_TUPLE) && (ix <= ERL_TUPLE_SIZE(ep))) {
erl_free_term(ERL_TUPLE_ELEMENT(ep, ix-1));
ERL_TUPLE_ELEMENT(ep, ix-1) = vp;
ERL_COUNT(vp)++;
return 1;
}
erl_err_msg("<ERROR> erl_setelement: Bad type to setelement or out of range \n");
return 0;
}
/*
* Create a FLOAT.
*/
ETERM *erl_mk_float (double d)
{
ETERM *ep;
#if defined(HAVE_ISFINITE)
/* Erlang does not handle Inf and NaN, so we return an error
* rather than letting the Erlang VM complain about a bad external
* term. */
if(!isfinite(d)) {
return NULL;
}
#endif
ep = erl_alloc_eterm(ERL_FLOAT);
ERL_COUNT(ep) = 1;
ERL_FLOAT_VALUE(ep) = d;
return ep;
}
/*
* Return the CONTENT of a VARIABLE with NAME.
* If the content is non-nil then bump its
* reference counter.
*/
ETERM *erl_var_content (const ETERM *ep, const char *name)
{
int i;
ETERM *vp;
if ((!ep) || (!name)) return NULL;
/* ASSERT(ep != NULL); */
switch(ERL_TYPE(ep))
{
case ERL_VARIABLE:
if (strcmp(ERL_VAR_NAME(ep), name) == 0) {
if ((vp = ERL_VAR_VALUE(ep)) != NULL) {
ERL_COUNT(vp)++;
return vp;
}
}
break;
case ERL_LIST:
while (ep && (ERL_TYPE(ep) != ERL_EMPTY_LIST)) {
if ((vp = erl_var_content(HEAD(ep), name))) return vp;
ep = TAIL(ep);
}
break;
case ERL_TUPLE:
for (i=0; i < ERL_TUPLE_SIZE(ep); i++)
if ((vp = erl_var_content(ERL_TUPLE_ELEMENT(ep, i), name)))
{
return vp;
}
break;
default:
/* variables can't occur in other types */
break;
}
/* nothing found ! */
return NULL;
}
/*
* Create an empty VARIABLE.
*/
ETERM *erl_mk_var(const char *s)
{
ETERM *ep;
if (!s) return NULL;
/* ASSERT(s != NULL); */
ep = erl_alloc_eterm(ERL_VARIABLE);
ERL_COUNT(ep) = 1;
ERL_VAR_LEN(ep) = strlen(s);
if ((ERL_VAR_NAME(ep) = strsave(s)) == NULL)
{
erl_free_term(ep);
erl_errno = ENOMEM;
return NULL;
}
ERL_VAR_VALUE(ep) = (ETERM *) NULL;
return ep;
}
/*
* Create a PORT.
*/
ETERM *erl_mk_port(const char *node,
unsigned int number,
unsigned char creation)
{
ETERM *ep;
if (!node) return NULL;
/* ASSERT(node != NULL); */
ep = erl_alloc_eterm(ERL_PORT);
ERL_COUNT(ep) = 1;
if (erl_atom_init_latin1(&ep->uval.portval.node, node) == NULL)
{
erl_free_term(ep);
erl_errno = ENOMEM;
return NULL;
}
erl_mk_port_helper(ep, number, creation);
return ep;
}
ETERM *erl_iolist_to_binary (const ETERM* term)
{
ETERM *dest;
int size;
char* ptr;
if (!term) return NULL;
/* ASSERT(term != NULL); */
/*
* Verify that the term is an I/O list and get its length.
*/
size = erl_iolist_length(term);
if (size == -1) {
return NULL;
}
/*
* Allocate the binary and copy the contents of the I/O list into it.
*/
dest = erl_alloc_eterm(ERL_BINARY);
ERL_COUNT(dest) = 1;
ERL_BIN_SIZE(dest) = size;
ptr = (char *)erl_malloc(size);
ERL_BIN_PTR(dest) = (unsigned char *)ptr;
iolist_to_buf(term, &ptr);
/*
* If ptr doesn't point exactly one byte beyond the end of the
* binary, something must be seriously wrong.
*/
if (ERL_BIN_PTR(dest) + size != (unsigned char *) ptr) return NULL;
/* ASSERT(ERL_BIN_PTR(dest) + size == (unsigned char *) ptr); */
return dest;
}
/*
* Dump (print for debugging) a term. Useful if/when things go wrong.
*/
void
dump_term (FILE *fp, ETERM *t)
{
if (fp == NULL) return;
fprintf(fp, "#<%p ", t);
if(t != NULL)
{
fprintf(fp, "count:%d, type:%d", ERL_COUNT(t), ERL_TYPE(t));
switch(ERL_TYPE(t))
{
case ERL_UNDEF:
fprintf(fp, "==undef");
break;
case ERL_INTEGER:
fprintf(fp, "==int, val:%d", ERL_INT_VALUE(t));
break;
case ERL_U_INTEGER:
fprintf(fp, "==uint, val:%u", ERL_INT_UVALUE(t));
break;
case ERL_FLOAT:
fprintf(fp, "==float, val:%g", ERL_FLOAT_VALUE(t));
break;
case ERL_ATOM:
fprintf(fp, "==atom, name:%p \"%s\"",
ERL_ATOM_PTR(t), ERL_ATOM_PTR(t));
break;
case ERL_BINARY:
fprintf(fp, "==binary, data:%p,%u",
ERL_BIN_PTR(t), ERL_BIN_SIZE(t));
break;
case ERL_PID:
fprintf(fp, "==pid, node:%p \"%s\"",
ERL_PID_NODE(t), ERL_PID_NODE(t));
break;
case ERL_PORT:
fprintf(fp, "==port, node:%p \"%s\"",
ERL_PORT_NODE(t), ERL_PORT_NODE(t));
break;
case ERL_REF:
fprintf(fp, "==ref, node:%p \"%s\"",
ERL_REF_NODE(t), ERL_REF_NODE(t));
break;
case ERL_CONS:
fprintf(fp, "==cons");
fprintf(fp, ", car:");
dump_term(fp, ERL_CONS_HEAD(t));
fprintf(fp, ", cdr:");
dump_term(fp, ERL_CONS_TAIL(t));
break;
case ERL_NIL:
fprintf(fp, "==nil");
break;
case ERL_TUPLE:
fprintf(fp, "==tuple, elems:%p,%u",
ERL_TUPLE_ELEMS(t), ERL_TUPLE_SIZE(t));
{
size_t i;
for(i = 0; i < ERL_TUPLE_SIZE(t); i++)
{
fprintf(fp, "elem[%u]:", i);
dump_term(fp, ERL_TUPLE_ELEMENT(t, i));
}
}
break;
case ERL_VARIABLE:
fprintf(fp, "==variable, name:%p \"%s\"",
ERL_VAR_NAME(t), ERL_VAR_NAME(t));
fprintf(fp, ", value:");
dump_term(fp, ERL_VAR_VALUE(t));
break;
default:
break;
}
}
fprintf(fp, ">");
}
/*
* FIXME: Deep (the whole tree) or shallow (just the top term) copy?
* The documentation never says, but the code as written below will
* make a deep copy. This should be documented.
*/
ETERM *erl_copy_term(const ETERM *ep)
{
int i;
ETERM *cp;
if (!ep) return NULL;
/* ASSERT(ep != NULL); */
cp = erl_alloc_eterm(ERL_TYPE(ep));
ERL_COUNT(cp) = 1;
switch(ERL_TYPE(cp)) {
case ERL_INTEGER:
case ERL_SMALL_BIG:
ERL_INT_VALUE(cp) = ERL_INT_VALUE(ep);
break;
case ERL_U_INTEGER:
case ERL_U_SMALL_BIG:
ERL_INT_UVALUE(cp) = ERL_INT_UVALUE(ep);
break;
case ERL_LONGLONG:
ERL_LL_VALUE(cp) = ERL_LL_VALUE(ep);
break;
case ERL_U_LONGLONG:
ERL_LL_UVALUE(cp) = ERL_LL_UVALUE(ep);
break;
case ERL_FLOAT:
ERL_FLOAT_VALUE(cp) = ERL_FLOAT_VALUE(ep);
break;
case ERL_ATOM:
if (!erl_atom_copy(&cp->uval.aval.d, &ep->uval.aval.d))
{
erl_free_term(cp);
erl_errno = ENOMEM;
return NULL;
}
break;
case ERL_PID:
/* FIXME: First copy the bit pattern, then duplicate the node
name and plug in. Somewhat ugly (also done with port and
ref below). */
memcpy(&cp->uval.pidval, &ep->uval.pidval, sizeof(Erl_Pid));
erl_atom_copy(&cp->uval.pidval.node, &ep->uval.pidval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_PORT:
memcpy(&cp->uval.portval, &ep->uval.portval, sizeof(Erl_Port));
erl_atom_copy(&cp->uval.portval.node, &ep->uval.portval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_REF:
memcpy(&cp->uval.refval, &ep->uval.refval, sizeof(Erl_Ref));
erl_atom_copy(&cp->uval.refval.node, &ep->uval.refval.node);
ERL_COUNT(cp) = 1;
break;
case ERL_LIST:
HEAD(cp) = erl_copy_term(HEAD(ep));
TAIL(cp) = erl_copy_term(TAIL(ep));
break;
case ERL_EMPTY_LIST:
break;
case ERL_TUPLE:
i = ERL_TUPLE_SIZE(cp) = ERL_TUPLE_SIZE(ep);
ERL_TUPLE_ELEMS(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_TUPLE_SIZE(ep); i++)
ERL_TUPLE_ELEMENT(cp,i) = erl_copy_term(ERL_TUPLE_ELEMENT(ep, i));
break;
case ERL_BINARY:
ERL_BIN_SIZE(cp) = ERL_BIN_SIZE(ep);
ERL_BIN_PTR(cp) = (unsigned char *) erl_malloc(ERL_BIN_SIZE(ep));
memcpy(ERL_BIN_PTR(cp), ERL_BIN_PTR(ep), ERL_BIN_SIZE(ep));
break;
case ERL_FUNCTION:
i = ERL_CLOSURE_SIZE(cp) = ERL_CLOSURE_SIZE(ep);
ERL_FUN_ARITY(cp) = ERL_FUN_ARITY(ep);
ERL_FUN_NEW_INDEX(cp) = ERL_FUN_NEW_INDEX(ep);
ERL_FUN_INDEX(cp) = erl_copy_term(ERL_FUN_INDEX(ep));
ERL_FUN_UNIQ(cp) = erl_copy_term(ERL_FUN_UNIQ(ep));
ERL_FUN_CREATOR(cp) = erl_copy_term(ERL_FUN_CREATOR(ep));
ERL_FUN_MODULE(cp) = erl_copy_term(ERL_FUN_MODULE(ep));
memcpy(ERL_FUN_MD5(cp), ERL_FUN_MD5(ep), sizeof(ERL_FUN_MD5(ep)));
ERL_CLOSURE(cp) = (ETERM**) erl_malloc(i * sizeof(ETERM*));
for(i=0; i < ERL_CLOSURE_SIZE(ep); i++)
ERL_CLOSURE_ELEMENT(cp,i) =
erl_copy_term(ERL_CLOSURE_ELEMENT(ep, i));
break;
default:
erl_err_msg("<ERROR> erl_copy_term: wrong type encountered !");
erl_free_term(cp);
return (ETERM *) NULL;
}
return cp;
}
int main(void)
#endif
{
ei_x_buff eix;
int index = 0;
ETERM **etermpp = NULL, *etermp = NULL;
char *charp = NULL;
unsigned char uchar, **ucharpp = NULL, *ucharp = NULL;
void *voidp = NULL;
Erl_Heap *erl_heapp = NULL;
int intx = 0;
int *intp = NULL;
unsigned int uintx, *uintp;
unsigned long *ulongp = NULL;
long longx = 0;
double doublex = 0.0;
short shortx = 42;
FILE *filep = NULL;
Erl_IpAddr erl_ipaddr = NULL;
ErlMessage *erlmessagep = NULL;
ErlConnect *erlconnectp = NULL;
struct hostent *hostp = NULL;
struct in_addr *inaddrp = NULL;
/* Converion to erl_interface format is in liberl_interface */
intx = erl_errno;
ei_encode_term(charp, &index, voidp);
ei_x_encode_term(&eix, voidp);
ei_decode_term(charp, &index, voidp);
erl_init(voidp, longx);
erl_connect_init(intx, charp,shortx);
erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx);
erl_connect(charp);
erl_xconnect(erl_ipaddr,charp);
erl_close_connection(intx);
erl_receive(intx, ucharp, intx);
erl_receive_msg(intx, ucharp, intx, erlmessagep);
erl_xreceive_msg(intx, ucharpp, intp, erlmessagep);
erl_send(intx, etermp, etermp);
erl_reg_send(intx, charp, etermp);
erl_rpc(intx,charp,charp,etermp);
erl_rpc_to(intx,charp,charp,etermp);
erl_rpc_from(intx,intx,erlmessagep);
erl_publish(intx);
erl_accept(intx,erlconnectp);
erl_thiscookie();
erl_thisnodename();
erl_thishostname();
erl_thisalivename();
erl_thiscreation();
erl_unpublish(charp);
erl_err_msg(charp);
erl_err_quit(charp);
erl_err_ret(charp);
erl_err_sys(charp);
erl_cons(etermp,etermp);
erl_copy_term(etermp);
erl_element(intx,etermp);
erl_hd(etermp);
erl_iolist_to_binary(etermp);
erl_iolist_to_string(etermp);
erl_iolist_length(etermp);
erl_length(etermp);
erl_mk_atom(charp);
erl_mk_binary(charp,intx);
erl_mk_empty_list();
erl_mk_estring(charp, intx);
erl_mk_float(doublex);
erl_mk_int(intx);
erl_mk_list(etermpp,intx);
erl_mk_pid(charp,uintx,uintx,uchar);
erl_mk_port(charp,uintx,uchar);
erl_mk_ref(charp,uintx,uchar);
erl_mk_long_ref(charp,uintx,uintx,uintx,uchar);
erl_mk_string(charp);
erl_mk_tuple(etermpp,intx);
erl_mk_uint(uintx);
erl_mk_var(charp);
erl_print_term(filep,etermp);
/* erl_sprint_term(charp,etermp); */
erl_size(etermp);
erl_tl(etermp);
erl_var_content(etermp, charp);
erl_format(charp);
erl_match(etermp, etermp);
erl_global_names(intx, intp);
erl_global_register(intx, charp, etermp);
erl_global_unregister(intx, charp);
erl_global_whereis(intx, charp, charp);
erl_init_malloc(erl_heapp,longx);
erl_alloc_eterm(uchar);
erl_eterm_release();
erl_eterm_statistics(ulongp,ulongp);
erl_free_array(etermpp,intx);
erl_free_term(etermp);
erl_free_compound(etermp);
erl_malloc(longx);
erl_free(voidp);
erl_compare_ext(ucharp, ucharp);
erl_decode(ucharp);
erl_decode_buf(ucharpp);
erl_encode(etermp,ucharp);
erl_encode_buf(etermp,ucharpp);
erl_ext_size(ucharp);
erl_ext_type(ucharp);
erl_peek_ext(ucharp,intx);
erl_term_len(etermp);
erl_gethostbyname(charp);
erl_gethostbyaddr(charp, intx, intx);
erl_gethostbyname_r(charp, hostp, charp, intx, intp);
erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
erl_init_resolve();
erl_distversion(intx);
erl_epmd_connect(inaddrp);
erl_epmd_port(inaddrp, charp, intp);
charp = ERL_ATOM_PTR(etermp);
intx = ERL_ATOM_SIZE(etermp);
ucharp = ERL_BIN_PTR(etermp);
intx = ERL_BIN_SIZE(etermp);
etermp = ERL_CONS_HEAD(etermp);
etermp = ERL_CONS_TAIL(etermp);
intx = ERL_COUNT(etermp);
doublex= ERL_FLOAT_VALUE(etermp);
uintx = ERL_INT_UVALUE(etermp);
intx = ERL_INT_VALUE(etermp);
intx = ERL_IS_ATOM(etermp);
intx = ERL_IS_BINARY(etermp);
intx = ERL_IS_CONS(etermp);
intx = ERL_IS_EMPTY_LIST(etermp);
intx = ERL_IS_FLOAT(etermp);
intx = ERL_IS_INTEGER(etermp);
intx = ERL_IS_LIST(etermp);
intx = ERL_IS_PID(etermp);
intx = ERL_IS_PORT(etermp);
intx = ERL_IS_REF(etermp);
intx = ERL_IS_TUPLE(etermp);
intx = ERL_IS_UNSIGNED_INTEGER(etermp);
uchar = ERL_PID_CREATION(etermp);
charp = ERL_PID_NODE(etermp);
uintx = ERL_PID_NUMBER(etermp);
uintx = ERL_PID_SERIAL(etermp);
uchar = ERL_PORT_CREATION(etermp);
charp = ERL_PORT_NODE(etermp);
uintx = ERL_PORT_NUMBER(etermp);
uchar = ERL_REF_CREATION(etermp);
intx = ERL_REF_LEN(etermp);
charp = ERL_REF_NODE(etermp);
uintx = ERL_REF_NUMBER(etermp);
uintp = ERL_REF_NUMBERS(etermp);
etermp = ERL_TUPLE_ELEMENT(etermp,intx);
intx = ERL_TUPLE_SIZE(etermp);
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EINVAL +
EIO +
EMSGSIZE +
ENOMEM +
ERL_ATOM +
ERL_BINARY +
ERL_ERROR +
ERL_EXIT +
ERL_FLOAT +
ERL_INTEGER +
ERL_LINK +
ERL_LIST +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_PID +
ERL_PORT +
ERL_REF +
ERL_REG_SEND +
ERL_SEND +
ERL_SMALL_BIG +
ERL_TICK +
ERL_TIMEOUT +
ERL_TUPLE +
ERL_UNLINK +
ERL_U_INTEGER +
ERL_U_SMALL_BIG +
ERL_VARIABLE +
ETIMEDOUT +
MAXNODELEN +
MAXREGLEN;
}
