bert

type Atom ¶

type Atom string

type DistributionHeader ¶

type DistributionHeader struct {
	// contains filtered or unexported fields
}

As of erts version 5.7.2 the old atom cache protocol was dropped and a new one was introduced. This atom cache protocol introduced the distribution header. Nodes with erts versions earlier than 5.7.2 can still communicate with new nodes, but no distribution header and no atom cache will be used.

The distribution header currently only contains an atom cache reference section, but could in the future contain more information. The distribution header precedes one or more Erlang terms on the external format. For more information see the documentation of the protocol between connected nodes in the distribution protocol documentation.

ATOM_CACHE_REF entries with corresponding AtomCacheReferenceIndex in terms encoded on the external format following a distribution header refers to the atom cache references made in the distribution header. The range is 0 <= AtomCacheReferenceIndex < 255, i.e., at most 255 different atom cache references from the following terms can be made.

func (dh DistributionHeader) GetAtom(atomCacheReferenceIndex uint8) (*Atom, error)

func (dh DistributionHeader) Update(r io.Reader) error

type Export ¶

type Export struct {
	Module   Atom
	Function Atom
	Arity    uint8
}

Export wraps the EXPORT_EXT tag type (113) This term is the encoding for external funs: fun M:F/A.

Module and Function are atoms (encoded using ATOM_EXT, SMALL_ATOM_EXT or ATOM_CACHE_REF).

Arity is an integer encoded using SMALL_INTEGER_EXT.

type Func ¶

type Func struct {
	Pid      Pid
	Module   Atom
	Index    uint32
	Uniq     uint32
	FreeVars []Term
}

Func wraps the FUN_EXT tag type (117)

Pid is a process identifier as in PID_EXT. It represents the process in which the fun was created.

Module is an encoded as an atom, using ATOM_EXT, SMALL_ATOM_EXT or ATOM_CACHE_REF. This is the module that the fun is implemented in.

Index is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT. It is typically a small index into the module's fun table.

Uniq is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT. Uniq is the hash value of the parse for the fun.

Free vars is NumFree number of terms, each one encoded according to its type.

type NewFunc ¶

type NewFunc struct {
	Arity     uint8
	Uniq      []byte
	Index     uint32
	Module    Atom
	OldIndex  uint32
	OldUnique uint32
	Pid       Pid
	FreeVars  []Term
}

NewFunc wraps the NEW_FUN_EXT tag type (112) This is the new encoding of internal funs: fun F/A and fun(Arg1,..) -> ... end.

Size is the total number of bytes, including the Size field.

Arity is the arity of the function implementing the fun.

Uniq is the 16 bytes MD5 of the significant parts of the Beam file.

Index is an index number. Each fun within a module has an unique index. Index is stored in big-endian byte order.

NumFree is the number of free variables.

Module is an encoded as an atom, using ATOM_EXT, SMALL_ATOM_EXT or ATOM_CACHE_REF. This is the module that the fun is implemented in.

OldIndex is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT. It is typically a small index into the module's fun table.

OldUniq is an integer encoded using SMALL_INTEGER_EXT or INTEGER_EXT. Uniq is the hash value of the parse tree for the fun.

Pid is a process identifier as in PID_EXT. It represents the process in which the fun was created.

Free vars is NumFree number of terms, each one encoded according to its type.

type NewReference ¶

type NewReference struct {
	Node     Atom
	Creation uint8
	ID       []uint32
}

NewReference wraps the NEW_REFERENCE_EXT tag type (114)

Node and Creation are as in REFERENCE_EXT.

ID contains a sequence of big-endian unsigned integers (4 bytes each, so N' is a multiple of 4), but should be regarded as uninterpreted data.

N' = 4 * Len.

In the first word (four bytes) of ID, only 18 bits are significant, the rest should be 0.

In Creation, only 2 bits are significant, the rest should be 0.

NEW_REFERENCE_EXT was introduced with distribution version 4. In version 4, N' should be at most 12

type Pid ¶

type Pid struct {
	Node     Atom
	ID       uint32
	Serial   uint32
	Creation uint8
}

Pid wraps the PID_EXT tag type (103)

Encode a process identifier object (obtained from spawn/3 or friends). The ID and Creation fields works just like in REFERENCE_EXT, while the Serial field is used to improve safety. In ID, only 15 bits are significant; the rest should be 0.

type Port ¶

type Port struct {
	Node     Atom
	ID       uint32
	Creation uint8
}

Port wraps the PORT_EXT tag type (102)

Encode a port object (obtained form open_port/2). The ID is a node specific identifier for a local port. Port operations are not allowed across node boundaries. The Creation works just like in REFERENCE_EXT.

type Reference ¶

type Reference struct {
	Node     Atom
	ID       uint32
	Creation uint8
}

Reference wraps the REFERENCE_EXT tag type (101)

Encode a reference object (an object generated with make_ref/0).

The Node term is an encoded atom, i.e. ATOM_EXT, SMALL_ATOM_EXT or ATOM_CACHE_REF.

The ID field contains a big-endian unsigned integer, but should be regarded as uninterpreted data since this field is node specific. Creation is a byte containing a node serial number that makes it possible to separate old (crashed) nodes from a new one.

In ID, only 18 bits are significant; the rest should be 0. In Creation, only 2 bits are significant; the rest should be 0. See NEW_REFERENCE_EXT.

type Request ¶

type Request struct {
	Kind      Atom
	Module    Atom
	Function  Atom
	Arguments []Term
}

func UnmarshalRequest(r io.Reader) (Request, error)

type Term ¶

type Term interface{}

func Decode(data []byte) (Term, error)

i, err := Decode([]byte{131, 97, 42})
if err != nil {
	fmt.Println(err)
}
fmt.Printf("%#v\n", i)
s, err := Decode([]byte{131, 107, 0, 3, 102, 111, 111})
if err != nil {
	fmt.Println(err)
}
fmt.Printf("%#v\n", s)
a, err := Decode([]byte{131, 104, 1, 100, 0, 3, 102, 111, 111})
if err != nil {
	fmt.Println(err)
}
fmt.Printf("%#v\n", a)

Output:

42
"foo"
[]bert.Term{"foo"}

func DecodeFrom(r io.Reader) (Term, error)