erlang-etf 1.0.0

data/lib/erlang/etf/integer.rb

@@ -0,0 +1,29 @@
+module Erlang
+  module ETF
+
+    #
+    # 1  | 4
+    # -- | ---
+    # 98 | Int
+    #
+    # Signed 32 bit integer in big-endian format (i.e. MSB first)
+    #
+    class Integer
+      include Term
+
+      uint8 :tag, always: Terms::INTEGER_EXT
+
+      int32be :int
+
+      finalize
+
+      def initialize(int)
+        @int = int
+      end
+
+      def __ruby_evolve__
+        int
+      end
+    end
+  end
+end

data/lib/erlang/etf/large_big.rb

@@ -0,0 +1,53 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 4 | 1    | n
+    # --- | - | ---- | ---------------
+    # 111 | n | Sign | d(0) ... d(n-1)
+    #
+    # Same as SMALL_BIG_EXT with the difference that the length field
+    # is an unsigned 4 byte integer.
+    #
+    class LargeBig
+      include Term
+
+      uint8 :tag, always: Terms::LARGE_BIG_EXT
+
+      uint32be :n, default: 0 do
+        uint8 :sign, always: -> { (integer >= 0) ? 0 : 1 }
+        string :integer
+      end
+
+      undef serialize_integer
+      def serialize_integer(buffer)
+        start = buffer.bytesize
+        buffer << [integer.abs.to_s(2).reverse!].pack(BIN_LSB_PACK)
+        self.n = buffer.bytesize - start
+        buffer
+      end
+
+      undef after_serialize_n
+      def after_serialize_n(buffer)
+        buffer[@n_start, BYTES_32] = serialize_n ""
+      end
+
+      deserialize do |buffer|
+        deserialize_n(buffer)
+        sign, = buffer.read(BYTES_8).unpack(UINT8_PACK)
+        self.integer = buffer.read(n).unpack(BIN_LSB_PACK).at(0).reverse!.to_i(2) * ((sign == 0) ? 1 : -1)
+        self
+      end
+
+      finalize
+
+      def initialize(integer)
+        @integer = integer
+      end
+
+      def __ruby_evolve__
+        integer
+      end
+    end
+  end
+end

data/lib/erlang/etf/large_tuple.rb

@@ -0,0 +1,55 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 4     | N
+    # --- | ----- | --------
+    # 105 | Arity | Elements
+    #
+    # Same as SMALL_TUPLE_EXT with the exception that Arity is an
+    # unsigned 4 byte integer in big endian format.
+    #
+    class LargeTuple
+      include Term
+
+      uint8 :tag, always: Terms::LARGE_TUPLE_EXT
+
+      uint32be :arity, always: -> { elements.size }
+
+      term :elements, type: :array
+
+      deserialize do |buffer|
+        arity, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
+        self.elements = []
+        arity.times do
+          self.elements << Terms.deserialize(buffer)
+        end
+        self
+      end
+
+      finalize
+
+      def initialize(elements)
+        @elements = elements
+      end
+
+      def serialize_header(buffer)
+        serialize_tag(buffer)
+        serialize_arity(buffer)
+      end
+
+      def bert?
+        elements[0].respond_to?(:atom_name) &&
+        elements[0].atom_name == BERT_PREFIX
+      end
+
+      def __ruby_evolve__
+        if bert?
+          ::Erlang::ETF::BERT.evolve(self)
+        else
+          ::Erlang::Tuple[*elements.map(&:__ruby_evolve__)]
+        end
+      end
+    end
+  end
+end

data/lib/erlang/etf/list.rb

@@ -0,0 +1,50 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 4   | Len      |
+    # --- | --- | -------- | ----
+    # 108 | Len | Elements | Tail
+    #
+    # Length is the number of elements that follows in the Elements
+    # section. Tail is the final tail of the list; it is NIL_EXT for a
+    # proper list, but may be anything type if the list is improper
+    # (for instance [a|b]).
+    #
+    class List
+      include Term
+
+      uint8 :tag, always: Terms::LIST_EXT
+
+      uint32be :len, always: -> { elements.size }
+
+      term :elements, type: :array
+      term :tail
+
+      deserialize do |buffer|
+        len, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
+        self.elements = []
+        len.times do
+          self.elements << Terms.deserialize(buffer)
+        end
+        deserialize_tail(buffer)
+        self
+      end
+
+      finalize
+
+      def initialize(elements, tail = Nil.new)
+        @elements = elements
+        @tail     = tail
+      end
+
+      def improper?
+        tail.class != ETF::Nil
+      end
+
+      def __ruby_evolve__
+        ::Erlang::List[*elements.map(&:__ruby_evolve__)].tail(tail.__ruby_evolve__)
+      end
+    end
+  end
+end

data/lib/erlang/etf/new_float.rb

@@ -0,0 +1,33 @@
+require 'bigdecimal'
+
+module Erlang
+  module ETF
+
+    #
+    # 1  | 8
+    # -- | ----------
+    # 70 | IEEE Float
+    #
+    # A float is stored as 8 bytes in big-endian IEEE format.
+    #
+    # This term is used in minor version 1 of the external format.
+    #
+    class NewFloat
+      include Term
+
+      uint8 :tag, always: Terms::NEW_FLOAT_EXT
+
+      doublebe :float
+
+      finalize
+
+      def initialize(float)
+        @float = float
+      end
+
+      def __ruby_evolve__
+        float
+      end
+    end
+  end
+end

data/lib/erlang/etf/new_fun.rb

@@ -0,0 +1,98 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 4    | 1     | 16   | 4     | 4       | N1     | N2       | N3      | N4  | N5
+    # --- | ---- | ----- | ---- | ----- | ------- | ------ | -------- | ------- | --- | ---------
+    # 112 | Size | Arity | Uniq | Index | NumFree | Module | Oldindex | OldUniq | Pid | Free Vars
+    #
+    # 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.
+    #
+    class NewFun
+      include Term
+
+      uint8 :tag, always: Terms::NEW_FUN_EXT
+
+      uint32be :size, default: 0, inclusive: true do
+        uint8 :arity
+        string :uniq
+        uint32be :index
+        uint32be :num_free, always: -> { free_vars.size }
+        term :mod
+        term :old_index
+        term :old_uniq
+        term :pid
+        term :free_vars, type: :array
+      end
+
+      undef deserialize_uniq
+      def deserialize_uniq(buffer)
+        self.uniq = buffer.read(16).unpack(UINT8_PACK + '*')
+      end
+
+      undef serialize_uniq
+      def serialize_uniq(buffer)
+        buffer << uniq.pack(UINT8_PACK + '*')
+      end
+
+      deserialize do |buffer|
+        deserialize_size(buffer)
+        deserialize_arity(buffer)
+        deserialize_uniq(buffer)
+        deserialize_index(buffer)
+        num_free, = buffer.read(BYTES_32).unpack(UINT32BE_PACK)
+        deserialize_mod(buffer)
+        deserialize_old_index(buffer)
+        deserialize_old_uniq(buffer)
+        deserialize_pid(buffer)
+        self.free_vars = []
+        num_free.times do
+          self.free_vars << Terms.deserialize(buffer)
+        end
+        self
+      end
+
+      finalize
+
+      def initialize(arity, uniq, index, mod, old_index, old_uniq, pid, free_vars = [])
+        self.arity     = arity
+        self.uniq      = uniq
+        self.index     = index
+        self.mod       = mod
+        self.old_index = old_index
+        self.old_uniq  = old_uniq
+        self.pid       = pid
+        self.free_vars = free_vars
+      end
+    end
+  end
+end

data/lib/erlang/etf/new_reference.rb

@@ -0,0 +1,59 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | 2   | N    | 1        | N'
+    # --- | --- | ---- | -------- | ------
+    # 114 | Len | Node | Creation | ID ...
+    #
+    # 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.
+    #
+    # See REFERENCE_EXT).
+    #
+    class NewReference
+      include Term
+
+      uint8 :tag, always: Terms::NEW_REFERENCE_EXT
+
+      uint16be :len, always: -> { ids.size }
+
+      term :node
+
+      int8 :creation, maximum: (1 << 2) - 1
+
+      uint32be :ids, type: :array, default: []
+
+      deserialize do |buffer|
+        len, = buffer.read(BYTES_16).unpack(UINT16BE_PACK)
+        deserialize_node(buffer)
+        deserialize_creation(buffer)
+        self.ids = []
+        len.times do
+          self.ids << buffer.read(BYTES_32).unpack(UINT32BE_PACK).at(0)
+        end
+        self
+      end
+
+      finalize
+
+      def initialize(node, creation, ids = [])
+        @node     = node
+        @creation = creation
+        @ids      = ids
+      end
+    end
+  end
+end

data/lib/erlang/etf/nil.rb

@@ -0,0 +1,23 @@
+module Erlang
+  module ETF
+
+    #
+    # 1
+    # ---
+    # 106
+    #
+    # The representation for an empty list, i.e. the Erlang syntax [].
+    #
+    class Nil
+      include Term
+
+      uint8 :tag, always: Terms::NIL_EXT
+
+      finalize
+
+      def __ruby_evolve__
+        []
+      end
+    end
+  end
+end

data/lib/erlang/etf/pid.rb

@@ -0,0 +1,45 @@
+module Erlang
+  module ETF
+
+    #
+    # 1   | N    | 4  | 4      | 1
+    # --- | ---- | -- | ------ | --------
+    # 103 | Node | ID | Serial | Creation
+    #
+    # 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.
+    #
+    class Pid
+      include Term
+
+      uint8 :tag, always: Terms::PID_EXT
+
+      term :node
+
+      uint32be :id,     maximum: (1 << 15) - 1
+      uint32be :serial, maximum: (1 << 13) - 1
+
+      int8 :creation, maximum: (1 << 2) - 1
+
+      finalize
+
+      def initialize(node, id, serial, creation)
+        @node     = node
+        @id       = id
+        @serial   = serial
+        @creation = creation
+      end
+
+      def __ruby_evolve__
+        ::Erlang::Pid.new(
+          node.__ruby_evolve__,
+          id,
+          serial,
+          creation
+        )
+      end
+    end
+  end
+end