ei - Routines for handling the Erlang binary term format.

ei_term:

         typedef struct {
             char ei_type;
             int arity;
             int size;
             union {
              long i_val;
              double d_val;
              char atom_name[MAXATOMLEN_UTF8];
              erlang_pid pid;
              erlang_port port;
              erlang_ref ref;
             } value;
         } ei_term;

           Structure written by ei_decode_ei_term(). The ei_type field is the type of the term which  equals  to
           what ei_get_type() sets *type to.

         ei_x_buff:
           A dynamically resized buffer. It is a struct with two fields of interest for the user:

           char*buff:
             Pointer to the dynamically allocated buffer.

           intindex:
             Offset to the next byte to write which also equals the amount of bytes currently written.

           An  ei_x_buff is initialized by calling either ei_x_new() or ei_x_new_with_version(). The memory used
           by an initialized ei_x_buff is released by calling ei_x_free().

         erlang_char_encoding:

         typedef enum {
             ERLANG_ASCII = 1,
             ERLANG_LATIN1 = 2,
             ERLANG_UTF8 = 4
         } erlang_char_encoding;

           The character encodings used for atoms. ERLANG_ASCII represents 7-bit ASCII. Latin-1  and  UTF-8  are
           different  extensions  of  7-bit  ASCII.  All  7-bit  ASCII  characters  are  valid Latin-1 and UTF-8
           characters. ASCII and Latin-1 both represent each character by  one  byte.  An  UTF-8  character  can
           consist of 1-4 bytes. Notice that these constants are bit-flags and can be combined with bitwise OR.

         erlang_fun:
           Opaque data type representing an Erlang fun.

         erlang_pid:
           Opaque data type representing an Erlang process identifier.

         erlang_port:
           Opaque data type representing an Erlang port identifier.

         erlang_ref:
           Opaque data type representing an Erlang reference.

         erlang_trace:
           Opaque data type representing an Erlang sequential trace token.

       Some tips on what to check when the emulator does not seem to receive the terms that you send:

         * Be careful with the version header, use ei_x_new_with_version() when appropriate.

         * Turn on distribution tracing on the Erlang node.

         * Check the result codes from ei_decode_-calls.

Ericsson AB                                     erl_interface 5.1                                       ei(3erl)

       The library ei contains macros and functions to encode and decode the Erlang binary term format.

       ei  allows  you  to  convert  atoms,  lists, numbers, and binaries to and from the binary format. This is
       useful when writing port programs and drivers.  ei  uses  a  given  buffer,  no  dynamic  memory  (except
       ei_decode_fun()) and is often quite fast.

       ei  also  handles C-nodes, C-programs that talks Erlang distribution with Erlang nodes (or other C-nodes)
       using the Erlang distribution format.The ei library is thread safe, and using threads,  one  process  can
       handle multiple C-nodes.

       The  decode  and  encode  functions  use a buffer and an index into the buffer, which points at the point
       where to encode and decode. The index is updated to  point  right  after  the  term  encoded/decoded.  No
       checking  is  done  whether  the term fits in the buffer or not. If encoding goes outside the buffer, the
       program can crash.

       All functions take two parameters:

         * buf is a pointer to the buffer where the binary data is or will be.

         * index is a pointer to an index into the buffer. This parameter is incremented with the  size  of  the
           term decoded/encoded.

       The data is thus at buf[*index] when an ei function is called.

       All  encode  functions  assume  that  the buf and index parameters point to a buffer large enough for the
       data. To get the size of an encoded term, without encoding it, pass NULL instead  of  a  buffer  pointer.
       Parameter  index  is  incremented, but nothing will be encoded. This is the way in ei to "preflight" term
       encoding.

       There are also encode functions that use a dynamic buffer. It is often more convenient to  use  these  to
       encode  data.  All encode functions comes in two versions; those starting with ei_x_ use a dynamic buffer
       of type ei_x_buff.

       All functions return 0 if successful, otherwise -1 (for example, if a term is not of the  expected  type,
       or the data to decode is an invalid Erlang term).

       Some of the decode functions need a pre-allocated buffer. This buffer must be allocated large enough, and
       for  non-compound  types the ei_get_type() function returns the size required (notice that for strings an
       extra byte is needed for the NULL-terminator).

intei_cmp_pids(erlang_pid*a,erlang_pid*b)

              Types:

                 erlang_pid

              Compare two process identifiers. The comparison is done the same way as Erlang does.

              Returns  0 if a and b are equal. Returns a value less than 0 if a compares as less than b. Returns
              a value larger than 0 if a compares as larger than b.

       intei_cmp_ports(erlang_port*a,erlang_port*b)

              Types:

                 erlang_port

              Compare two port identifiers. The comparison is done the same way as Erlang does.

              Returns 0 if a and b are equal. Returns a value less than 0 if a compares as less than b.  Returns
              a value larger than 0 if a compares as larger than b.

       intei_cmp_refs(erlang_ref*a,erlang_ref*b)

              Types:

                 erlang_ref

              Compare two references. The comparison is done the same way as Erlang does.

              Returns  0 if a and b are equal. Returns a value less than 0 if a compares as less than b. Returns
              a value larger than 0 if a compares as larger than b.

       intei_decode_atom(constchar*buf,int*index,char*p)

              Decodes an atom from the binary format. The NULL-terminated name of the atom is placed  at  p.  At
              most MAXATOMLEN bytes can be placed in the buffer.

       intei_decode_atom_as(constchar*buf,int*index,char*p,intplen,erlang_char_encodingwant,erlang_char_encoding*was,erlang_char_encoding*result)

              Types:

                 erlang_char_encoding

              Decodes an atom from the binary format. The NULL-terminated name of the atom is placed  in  buffer
              at p of length plen bytes.

              The  wanted  string encoding is specified by want. The original encoding used in the binary format
              (Latin-1 or UTF-8) can be obtained from *was. The encoding of the resulting string  (7-bit  ASCII,
              Latin-1,  or  UTF-8)  can  be  obtained from *result. Both was and result can be NULL. *result can
              differ from want if want is a  bitwise  OR'd  combination  like  ERLANG_LATIN1|ERLANG_UTF8  or  if
              *result turns out to be pure 7-bit ASCII (compatible with both Latin-1 and UTF-8).

              This  function  fails  if  the atom is too long for the buffer or if it cannot be represented with
              encoding want.

              This function was introduced in Erlang/OTP R16 as part of a first step to support UTF-8 atoms.

       intei_decode_bignum(constchar*buf,int*index,mpz_tobj)

              Decodes an integer in the binary format to a GMP mpz_t integer.  To  use  this  function,  the  ei
              library must be configured and compiled to use the GMP library.

       intei_decode_binary(constchar*buf,int*index,void*p,long*len)

              Decodes  a  binary  from the binary format. Parameter len is set to the actual size of the binary.
              Notice that ei_decode_binary() assumes that there is enough room for the binary. The size required
              can be fetched by ei_get_type().

       intei_decode_bitstring(constchar*buf,int*index,constchar**pp,unsignedint*bitoffsp,size_t*nbitsp)

              Decodes a bit string from the binary format.

                pp:
                  Either  NULL  or  *pp  returns a pointer to the first byte of the bit string. The returned bit
                  string is readable as long as the buffer pointed to by buf is readable and not written to.

                bitoffsp:
                  Either NULL or *bitoffsp returns the number of unused bits in the first  byte  pointed  to  by
                  *pp.  The  value  of  *bitoffsp is between 0 and 7. Unused bits in the first byte are the most
                  significant bits.

                nbitsp:
                  Either NULL or *nbitsp returns the length of the bit string in bits.

              Returns 0 if it was a bit string term.

              The number of bytes pointed to by *pp, which are part of the bit string, is (*bitoffsp+*nbitsp+7)/8. If (*bitoffsp+*bitsp)%8>0 then only (*bitoffsp+*bitsp)%8 bits of  the  last  byte  are
              used. Unused bits in the last byte are the least significant bits.

              The values of unused bits in the first and last byte are undefined and cannot be relied on.

              Number  of  bits may be divisible by 8, which means a binary decodable by ei_decode_binary is also
              decodable by ei_decode_bitstring.

       intei_decode_boolean(constchar*buf,int*index,int*p)

              Decodes a boolean value from the binary format. A boolean is actually an atom, true decodes 1  and
              false decodes 0.

       intei_decode_char(constchar*buf,int*index,char*p)

              Decodes  a  char  (8-bit) integer between 0-255 from the binary format. For historical reasons the
              returned integer is of type char. Your C code is to consider the returned  value  to  be  of  type
              unsignedchar even if the C compilers and system can define char to be signed.

       intei_decode_double(constchar*buf,int*index,double*p)

              Decodes a double-precision (64-bit) floating point number from the binary format.

       intei_decode_ei_term(constchar*buf,int*index,ei_term*term)

              Types:

                 ei_term

              Decodes  any  term, or at least tries to. If the term pointed at by *index in buf fits in the term
              union, it is decoded, and the appropriate field in term->value is set, and *index  is  incremented
              by the term size.

              The  function  returns 1 on successful decoding, -1 on error, and 0 if the term seems alright, but
              does not fit in the term structure. If 1 is returned, the index is incremented, and term  contains
              the decoded term.

              The  term structure contains the arity for a tuple or list, size for a binary, string, or atom. It
              contains a term if it is any of the following: integer, float, atom, pid, port, or ref.

       intei_decode_fun(constchar*buf,int*index,erlang_fun*p)voidfree_fun(erlang_fun*f)

              Types:

                 erlang_fun

              Decodes a fun from the binary format. Parameter p  is  to  be  NULL  or  point  to  an  erlang_fun
              structure.  This  is  the  only  decode  function that allocates memory. When the erlang_fun is no
              longer needed, it is to be freed with free_fun. (This has to do with the  arbitrary  size  of  the
              environment for a fun.)

       intei_decode_iodata(constchar*buf,int*index,int*size,char*outbuf)

              Decodes  a  term  of  the  type  iodata(). The iodata() term will be flattened an written into the
              buffer pointed to by the outbuf argument. The byte size of the iodata is written into the  integer
              variable  pointed  to  by  the size argument. Both size and outbuf can be set to NULL. The integer
              pointed to by the index argument is updated to refer to the term following after the iodata() term
              regardless of the the state of the size and the outbuf arguments.

              Note that the buffer pointed to by the outbuf argument must be large enough if a non NULL value is
              passed as outbuf. You typically want to call ei_decode_iodata() twice. First with a non NULLsize
              argument  and a NULLoutbuf argument in order to determine the size of the buffer needed, and then
              once again in order to do the actual decoding. Note that the integer pointed to by index  will  be
              updated  by  the call determining the size as well, so you need to reset it before the second call
              doing the actual decoding.

              Returns 0 on success and -1 on failure. Failure might be either due to  invalid  encoding  of  the
              term  or due to the term not being of the type iodata(). On failure, the integer pointed to by the
              index argument will be updated to refer to the sub term where the failure was detected.

       intei_decode_list_header(constchar*buf,int*index,int*arity)

              Decodes a list header from the binary format. The number of elements is  returned  in  arity.  The
              arity+1  elements  follow (the last one is the tail of the list, normally an empty list). If arity
              is 0, it is an empty list.

              Notice that lists are encoded as strings if they consist entirely of integers in the range 0..255.
              This function do not decode such strings, use ei_decode_string() instead.

       intei_decode_long(constchar*buf,int*index,long*p)

              Decodes  a  long  integer  from  the  binary  format.  If  the  code  is  64  bits,  the  function
              ei_decode_long() is the same as ei_decode_longlong().

       intei_decode_longlong(constchar*buf,int*index,longlong*p)

              Decodes a GCC longlong or Visual C++ __int64 (64-bit) integer from the binary format.

       intei_decode_map_header(constchar*buf,int*index,int*arity)

              Decodes  a map header from the binary format. The number of key-value pairs is returned in *arity.
              Keys and values follow in this order: K1,V1,K2,V2,...,Kn,Vn. This makes a total  of  arity*2
              terms. If arity is zero, it is an empty map. A correctly encoded map does not have duplicate keys.

       intei_decode_pid(constchar*buf,int*index,erlang_pid*p)

              Types:

                 erlang_pid

              Decodes a process identifier (pid) from the binary format.

       intei_decode_port(constchar*buf,int*index,erlang_port*p)

              Types:

                 erlang_port

              Decodes a port identifier from the binary format.

       intei_decode_ref(constchar*buf,int*index,erlang_ref*p)

              Types:

                 erlang_ref

              Decodes a reference from the binary format.

       intei_decode_string(constchar*buf,int*index,char*p)

              Decodes  a  string  from the binary format. A string in Erlang is a list of integers between 0 and
              255. Notice that as the string is  just  a  list,  sometimes  lists  are  encoded  as  strings  by
              term_to_binary/1, even if it was not intended.

              The  string  is  copied  to  p,  and  enough space must be allocated. The returned string is NULL-
              terminated, so you must add an extra byte to the memory requirement.

       intei_decode_trace(constchar*buf,int*index,erlang_trace*p)

              Types:

                 erlang_trace

              Decodes an Erlang trace token from the binary format.

       intei_decode_tuple_header(constchar*buf,int*index,int*arity)

              Decodes a tuple header, the number of elements is returned in arity. The tuple elements follow  in
              order in the buffer.

       intei_decode_ulong(constchar*buf,int*index,unsignedlong*p)

              Decodes  an  unsigned  long  integer  from the binary format. If the code is 64 bits, the function
              ei_decode_ulong() is the same as ei_decode_ulonglong().

       intei_decode_ulonglong(constchar*buf,int*index,unsignedlonglong*p)

              Decodes a GCC unsignedlonglong or Visual C++ unsigned__int64 (64-bit) integer from  the  binary
              format.

       intei_decode_version(constchar*buf,int*index,int*version)

              Decodes  the version magic number for the Erlang binary term format. It must be the first token in
              a binary term.

       intei_encode_atom(char*buf,int*index,constchar*p)intei_encode_atom_len(char*buf,int*index,constchar*p,intlen)intei_x_encode_atom(ei_x_buff*x,constchar*p)intei_x_encode_atom_len(ei_x_buff*x,constchar*p,intlen)

              Types:

                 ei_x_buff

              Encodes an atom in the binary format. Parameter p is the name of the  atom  in  Latin-1  encoding.
              Only  up  to  MAXATOMLEN-1  bytes  are  encoded. The name is to be NULL-terminated, except for the
              ei_x_encode_atom_len() function.

       intei_encode_atom_as(char*buf,int*index,constchar*p,erlang_char_encodingfrom_enc,erlang_char_encodingto_enc)intei_encode_atom_len_as(char*buf,int*index,constchar*p,intlen,erlang_char_encodingfrom_enc,erlang_char_encodingto_enc)intei_x_encode_atom_as(ei_x_buff*x,constchar*p,erlang_char_encodingfrom_enc,erlang_char_encodingto_enc)intei_x_encode_atom_len_as(ei_x_buff*x,constchar*p,intlen,erlang_char_encodingfrom_enc,erlang_char_encodingto_enc)

              Types:

                 ei_x_bufferlang_char_encoding

              Encodes an atom in the binary format. Parameter p is the name of the atom with character  encoding
              from_enc (ASCII, Latin-1, or UTF-8). The name must either be NULL-terminated or a function variant
              with a len parameter must be used.

              The encoding fails if p is not a valid string in encoding from_enc.

              Argument  to_enc  is  ignored. As from Erlang/OTP 20 the encoding is always done in UTF-8 which is
              readable by nodes as old as Erlang/OTP R16.

       intei_encode_bignum(char*buf,int*index,mpz_tobj)intei_x_encode_bignum(ei_x_buff*x,mpz_tobj)

              Types:

                 ei_x_buff

              Encodes a GMP mpz_t integer to binary format. To  use  this  function,  the  ei  library  must  be
              configured and compiled to use the GMP library.

       intei_encode_binary(char*buf,int*index,constvoid*p,longlen)intei_x_encode_binary(ei_x_buff*x,constvoid*p,longlen)

              Types:

                 ei_x_buff

              Encodes a binary in the binary format. The data is at p, of len bytes length.

       intei_encode_bitstring(char*buf,int*index,constchar*p,size_tbitoffs,size_tnbits)intei_x_encode_bitstring(ei_x_buff*x,constchar*p,size_tbitoffs,size_tnbits)

              Types:

                 ei_x_buff

              Encodes a bit string in the binary format.

              The  data  is at p. The length of the bit string is nbits bits. The first bitoffs bits of the data
              at p are unused. The first byte which is part of the bit string  is  p[bitoffs/8].  The  bitoffs%8
              most significant bits of the first byte p[bitoffs/8] are unused.

              The  number  of  bytes  which  is part of the bit string is (bitoffs+nbits+7)/8. If (bitoffs+nbits)%8>0 then only (bitoffs+nbits)%8 bits of the last byte are used. Unused bits in the last
              byte are the least significant bits.

              The values of unused bits are disregarded and does not need to be cleared.

       intei_encode_boolean(char*buf,int*index,intp)intei_x_encode_boolean(ei_x_buff*x,intp)

              Types:

                 ei_x_buff

              Encodes a boolean value as the atom true if p is not zero, or false if p is zero.

       intei_encode_char(char*buf,int*index,charp)intei_x_encode_char(ei_x_buff*x,charp)

              Types:

                 ei_x_buff

              Encodes a char (8-bit) as an integer between 0-255 in the binary format.  For  historical  reasons
              the  integer  argument is of type char. Your C code is to consider the specified argument to be of
              type unsignedchar even if the C compilers and system may define char to be signed.

       intei_encode_double(char*buf,int*index,doublep)intei_x_encode_double(ei_x_buff*x,doublep)

              Types:

                 ei_x_buff

              Encodes a double-precision (64-bit) floating point number in the binary format.

              Returns -1 if the floating point number is not finite.

       intei_encode_empty_list(char*buf,int*index)intei_x_encode_empty_list(ei_x_buff*x)

              Types:

                 ei_x_buff

              Encodes an empty list. It is often used at the tail of a list.

       intei_encode_fun(char*buf,int*index,consterlang_fun*p)intei_x_encode_fun(ei_x_buff*x,consterlang_fun*fun)

              Types:

                 ei_x_bufferlang_fun

              Encodes a fun in the binary format. Parameter p points to an erlang_fun structure. The  erlang_fun
              is not freed automatically, the free_fun is to be called if the fun is not needed after encoding.

       intei_encode_list_header(char*buf,int*index,intarity)intei_x_encode_list_header(ei_x_buff*x,intarity)

              Types:

                 ei_x_buff

              Encodes  a  list header, with a specified arity. The next arity+1 terms are the elements (actually
              its arity cons cells) and the tail of the list. Lists and tuples are encoded recursively, so  that
              a list can contain another list or tuple.

              For example, to encode the list [c,d,[e|f]]:

              ei_encode_list_header(buf, &i, 3);
              ei_encode_atom(buf, &i, "c");
              ei_encode_atom(buf, &i, "d");
              ei_encode_list_header(buf, &i, 1);
              ei_encode_atom(buf, &i, "e");
              ei_encode_atom(buf, &i, "f");
              ei_encode_empty_list(buf, &i);

          Note:
              It  may  seem  that  there  is  no  way to create a list without knowing the number of elements in
              advance. But indeed there is a way. Notice that the list [a,b,c] can be written as  [a|[b|[c]]]. Using this, a list can be written as conses.

              To encode a list, without knowing the arity in advance:

              while (something()) {
                  ei_x_encode_list_header(&x, 1);
                  ei_x_encode_ulong(&x, i); /* just an example */
              }
              ei_x_encode_empty_list(&x);

       intei_encode_long(char*buf,int*index,longp)intei_x_encode_long(ei_x_buff*x,longp)

              Types:

                 ei_x_buff

              Encodes a long integer in the binary format. If the code is 64 bits, the function ei_encode_long()
              is the same as ei_encode_longlong().

       intei_encode_longlong(char*buf,int*index,longlongp)intei_x_encode_longlong(ei_x_buff*x,longlongp)

              Types:

                 ei_x_buff

              Encodes a GCC longlong or Visual C++ __int64 (64-bit) integer in the binary format.

       intei_encode_map_header(char*buf,int*index,intarity)intei_x_encode_map_header(ei_x_buff*x,intarity)

              Types:

                 ei_x_buff

              Encodes  a map header, with a specified arity. The next arity*2 terms encoded will be the keys and
              values of the map encoded in the following order: K1,V1,K2,V2,...,Kn,Vn.

              For example, to encode the map #{a=>"Apple",b=>"Banana"}:

              ei_x_encode_map_header(&x, 2);
              ei_x_encode_atom(&x, "a");
              ei_x_encode_string(&x, "Apple");
              ei_x_encode_atom(&x, "b");
              ei_x_encode_string(&x, "Banana");

              A correctly encoded map cannot have duplicate keys.

       intei_encode_pid(char*buf,int*index,consterlang_pid*p)intei_x_encode_pid(ei_x_buff*x,consterlang_pid*p)

              Types:

                 ei_x_bufferlang_pid

              Encodes an Erlang process identifier (pid)  in  the  binary  format.  Parameter  p  points  to  an
              erlang_pid  structure  which  should  either  have  been  obtained  earlier  with ei_decode_pid(),
              ei_self() or created by ei_make_pid().

       intei_encode_port(char*buf,int*index,consterlang_port*p)intei_x_encode_port(ei_x_buff*x,consterlang_port*p)

              Types:

                 ei_x_bufferlang_port

              Encodes an Erlang port in the binary format. Parameter p points to an erlang_port structure  which
              should have been obtained earlier with ei_decode_port(),

       intei_encode_ref(char*buf,int*index,consterlang_ref*p)intei_x_encode_ref(ei_x_buff*x,consterlang_ref*p)

              Types:

                 ei_x_bufferlang_ref

              Encodes  an  Erlang  reference in the binary format. Parameter p points to an erlang_ref structure
              which either should have been obtained earlier with ei_decode_ref(), or created by ei_make_ref().

       intei_encode_string(char*buf,int*index,constchar*p)intei_encode_string_len(char*buf,int*index,constchar*p,intlen)intei_x_encode_string(ei_x_buff*x,constchar*p)intei_x_encode_string_len(ei_x_buff*x,constchar*s,intlen)

              Types:

                 ei_x_buff

              Encodes a string in the binary format. (A string in  Erlang  is  a  list,  but  is  encoded  as  a
              character  array  in  the  binary  format.)  The  string  is to be NULL-terminated, except for the
              ei_x_encode_string_len() function.

       intei_encode_trace(char*buf,int*index,consterlang_trace*p)intei_x_encode_trace(ei_x_buff*x,consterlang_trace*p)

              Types:

                 ei_x_bufferlang_trace

              Encodes an Erlang trace token in the binary format. Parameter p points to a erlang_trace structure
              which should have been obtained earlier with ei_decode_trace().

       intei_encode_tuple_header(char*buf,int*index,intarity)intei_x_encode_tuple_header(ei_x_buff*x,intarity)

              Types:

                 ei_x_buff

              Encodes a tuple header, with a specified arity. The next arity terms encoded will be the  elements
              of  the tuple. Tuples and lists are encoded recursively, so that a tuple can contain another tuple
              or list.

              For example, to encode the tuple {a,{b,{}}}:

              ei_encode_tuple_header(buf, &i, 2);
              ei_encode_atom(buf, &i, "a");
              ei_encode_tuple_header(buf, &i, 2);
              ei_encode_atom(buf, &i, "b");
              ei_encode_tuple_header(buf, &i, 0);

       intei_encode_ulong(char*buf,int*index,unsignedlongp)intei_x_encode_ulong(ei_x_buff*x,unsignedlongp)

              Types:

                 ei_x_buff

              Encodes an unsigned long integer in the binary format. If  the  code  is  64  bits,  the  function
              ei_encode_ulong() is the same as ei_encode_ulonglong().

       intei_encode_ulonglong(char*buf,int*index,unsignedlonglongp)intei_x_encode_ulonglong(ei_x_buff*x,unsignedlonglongp)

              Types:

                 ei_x_buff

              Encodes  a  GCC  unsignedlonglong or Visual C++ unsigned__int64 (64-bit) integer in the binary
              format.

       intei_encode_version(char*buf,int*index)intei_x_encode_version(ei_x_buff*x)

              Types:

                 ei_x_buff

              Encodes a version magic number for the binary format. Must be the first token in a binary term.

       intei_get_type(constchar*buf,constint*index,int*type,int*size)

              Returns the type in *type and size in *size of the encoded term. For strings and  atoms,  size  is
              the number of characters not including the terminating NULL. For binaries and bitstrings, *size is
              the  number  of  bytes.  For  lists, tuples and maps, *size is the arity of the object. For bignum
              integers, *size is the number of bytes for the absolute value of  the  bignum.  For  other  types,
              *size is 0. In all cases, index is left unchanged.

              Currently *type is one of:

                ERL_ATOM_EXT:
                  Decode using either ei_decode_atom(), ei_decode_atom_as(), or ei_decode_boolean().

                ERL_BINARY_EXT:
                  Decode using either ei_decode_binary(), ei_decode_bitstring(), or ei_decode_iodata().

                ERL_BIT_BINARY_EXT:
                  Decode using ei_decode_bitstring().

                ERL_FLOAT_EXT:
                  Decode using ei_decode_double().

                ERL_NEW_FUN_EXT
                  ERL_FUN_EXT
                  ERL_EXPORT_EXT: Decode using ei_decode_fun().

                ERL_SMALL_INTEGER_EXT
                  ERL_INTEGER_EXT
                  ERL_SMALL_BIG_EXT
                  ERL_LARGE_BIG_EXT:     Decode     using     either     ei_decode_char(),     ei_decode_long(),
                  ei_decode_longlong(), ei_decode_ulong(), ei_decode_ulonglong(), or ei_decode_bignum().

                ERL_LIST_EXT
                  ERL_NIL_EXT: Decode using either ei_decode_list_header(), or ei_decode_iodata().

                ERL_STRING_EXT:
                  Decode using either ei_decode_string(), or ei_decode_iodata().

                ERL_MAP_EXT:
                  Decode using ei_decode_map_header().

                ERL_PID_EXT:
                  Decode using ei_decode_pid().

                ERL_PORT_EXT:
                  Decode using ei_decode_port().

                ERL_NEW_REFERENCE_EXT:
                  Decode using ei_decode_ref().

                ERL_SMALL_TUPLE_EXT
                  ERL_LARGE_TUPLE_EXT: Decode using ei_decode_tuple_header().

              Instead of decoding a term you can also skipped past it if you are not interested in the  data  by
              usage of ei_skip_term().

       intei_init(void)

              Initialize  the ei library. This function should be called once (and only once) before calling any
              other functionality in the ei library.

              On success zero is returned. On failure a posix error code is returned.

       intei_print_term(FILE*fp,constchar*buf,int*index)intei_s_print_term(char**s,constchar*buf,int*index)

              Prints a term, in clear text, to the file specified by fp, or the buffer pointed to by s. It tries
              to resemble the term printing in the Erlang shell.

              In ei_s_print_term(), parameter s is to point to a dynamically (malloc) allocated string of BUFSIZ
              bytes or a NULL pointer. The string can be reallocated (and *s can be updated) by this function if
              the result is more than BUFSIZ characters. The string returned is NULL-terminated.

              The return value is the number of characters written to the file or string, or  -1  if  buf[index]
              does not contain a valid term. Unfortunately, I/O errors on fp is not checked.

              Argument  index is updated, that is, this function can be viewed as a decode function that decodes
              a term into a human-readable format.

       voidei_set_compat_rel(unsignedrelease_number)

              In general, the ei library is guaranteed to be compatible with other  Erlang/OTP  components  that
              are 2 major releases older or newer than the ei library itself.

              Sometimes  an  exception to the above rule has to be made to make new features (or even bug fixes)
              possible. A call to ei_set_compat_rel(release_number) sets the ei library in compatibility mode of
              OTP release release_number.

              The only useful value for release_number is currently 21. This will only be  useful  and  have  an
              effect  if  bitstrings  or  exportfuns  are received from a connected node. Before OTP 22, bit
              strings and export funs were not supported by ei. They were instead encoded using an  undocumented
              fallback tuple format when sent from the emulator to ei:

                Bitstring:
                  The  term  <<42,1:1>>  was  encoded as {<<42,128>>,1}. The first element of the tuple is a
                  binary and the second element denotes how many bits of the last bytes  are  part  of  the  bit
                  string.  In  this  example only the most significant bit of the last byte (128) is part of the
                  bit string.

                Exportfun:
                  The term funlists:map/2 was encoded as {lists,map}. A tuple with the module, function  and  a
                  missing arity.

              If  ei_set_compat_rel(21) is not called then a connected emulator will send bit strings and export
              funs correctly encoded. The functions ei_decode_bitstring and ei_decode_fun  has  to  be  used  to
              decode  such  terms.  Calling ei_set_compat_rel(21) should only be done as a workaround to keep an
              old implementation alive, which expects to receive the undocumented tuple formats for bit  strings
              and/or export funs.

          Note:
              If  this  function  is  called,  it  can  only  be called once and must be called before any other
              functions in the ei library are called.

       intei_skip_term(constchar*buf,int*index)

              Skips a term in the specified buffer; recursively skips elements of lists and tuples,  so  that  a
              full term is skipped. This is a way to get the size of an Erlang term.

              buf is the buffer.

              index is updated to point right after the term in the buffer.

          Note:
              This  can be useful when you want to hold arbitrary terms: skip them and copy the binary term data
              to some buffer.

              Returns 0 on success, otherwise -1.

       intei_x_append(ei_x_buff*x,constei_x_buff*x2)intei_x_append_buf(ei_x_buff*x,constchar*buf,intlen)

              Types:

                 ei_x_buff

              Appends data at the end of buffer x.

       intei_x_format(ei_x_buff*x,constchar*fmt,...)intei_x_format_wo_ver(ei_x_buff*x,constchar*fmt,...)

              Types:

                 ei_x_bufferlang_pid

              Formats a term, given as a string, to a buffer.  Works  like  a  sprintf  for  Erlang  terms.  fmt
              contains  a  format  string, with arguments like ~d, to insert terms from variables. The following
              formats are supported (with the C types given):

              ~a  An atom, char*
              ~c  A character, char
              ~s  A string, char*
              ~i  An integer, int
              ~l  A long integer, long int
              ~u  A unsigned long integer, unsigned long int
              ~f  A float, float
              ~d  A double float, double float
              ~p  An Erlang pid, erlang_pid*

              For example, to encode a tuple with some stuff:

              ei_x_format("{~a,~i,~d}", "numbers", 12, 3.14159)
              encodes the tuple {numbers,12,3.14159}

              ei_x_format_wo_ver() formats into a buffer, without the initial version byte.

       intei_x_free(ei_x_buff*x)

              Types:

                 ei_x_buff

              Deallocates the dynamically allocated content of the buffer referred by x. After deallocation, the
              buff field is set to NULL.

       intei_x_new(ei_x_buff*x)intei_x_new_with_version(ei_x_buff*x)

              Types:

                 ei_x_buff

              Initialize the dynamically realizable buffer referred to by x. The fields of the structure pointed
              to by parameter x is filled in, and a default buffer is  allocated.  ei_x_new_with_version()  also
              puts  an  initial  version byte, which is used in the binary format (so that ei_x_encode_version()
              will not be needed.)

       ei - Routines for handling the Erlang binary term format.