Merge branch 'function-signature-parser' into develop

Author: tsutsu

.gitignore

@@ -18,3 +18,7 @@ erl_crash.dump
 
 # Also ignore archive artifacts (built via "mix archive.build").
 *.ez
+
+# Ignore generated code from yecc and leex
+src/*_lexer.erl
+src/*_parser.erl

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.1.9
+* Add support for parsing ABI specification documents (`.abi.json` files)
+* Reimplement function signature parsing using a BNF grammar
+* Fix potential stack overflow during encoding/decoding
 # 0.1.8
 * Fix ordering of elements in tuples
 # 0.1.7
@@ -11,4 +15,4 @@
 # 0.1.3
 * Bugfix for tuples to properly handle head/tail encoding
 # 0.1.2
-* Add support for tuples, fixed-length and variable length arrays
+* Add support for tuples, fixed-length and variable length arrays

lib/abi.ex

@@ -36,7 +36,7 @@ defmodule ABI do
       "b85d0bd200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001"
   """
   def encode(function_signature, data) when is_binary(function_signature) do
-    encode(ABI.FunctionSelector.decode(function_signature), data)
+    encode(ABI.Parser.parse!(function_signature), data)
   end
   def encode(%ABI.FunctionSelector{} = function_selector, data) do
     ABI.TypeEncoder.encode(data, function_selector)
@@ -67,7 +67,7 @@ defmodule ABI do
       [<<1::160>>, true]
   """
   def decode(function_signature, data) when is_binary(function_signature) do
-    decode(ABI.FunctionSelector.decode(function_signature), data)
+    decode(ABI.Parser.parse!(function_signature), data)
   end
   def decode(%ABI.FunctionSelector{} = function_selector, data) do
     ABI.TypeDecoder.decode(data, function_selector)

lib/abi/function_selector.ex

@@ -19,8 +19,7 @@ defmodule ABI.FunctionSelector do
   defstruct [:function, :types, :returns]
 
   @doc """
-  Decodes a function selector to struct. This is a simple version
-  and we may opt to do format parsing later.
+  Decodes a function selector to a struct.
 
   ## Examples
 
@@ -82,23 +81,7 @@ defmodule ABI.FunctionSelector do
       }
   """
   def decode(signature) do
-    captures = Regex.named_captures(~r/(?<function>[a-zA-Z_$][a-zA-Z_$0-9]*)?\((?<types>(([^,]+),?)*)\)/, signature)
-
-    if captures["function"] != "" do
-      # Encode as a function call
-      %ABI.FunctionSelector{
-        function: captures["function"],
-        types: decode_raw(captures["types"]),
-        returns: nil
-      }
-    else
-      # Encode as a tuple
-      %ABI.FunctionSelector{
-        function: nil,
-        types: [{:tuple, decode_raw(captures["types"])}],
-        returns: nil
-      }
-    end
+    ABI.Parser.parse!(signature, as: :selector)
   end
 
   @doc """
@@ -108,11 +91,13 @@ defmodule ABI.FunctionSelector do
 
       iex> ABI.FunctionSelector.decode_raw("string,uint256")
       [:string, {:uint, 256}]
+
+      iex> ABI.FunctionSelector.decode_raw("")
+      []
   """
   def decode_raw(type_string) do
-    type_string
-    |> String.split(",", trim: true)
-    |> Enum.map(&decode_type/1)
+    {:tuple, types} = decode_type("(#{type_string})")
+    types
   end
 
   @doc false
@@ -143,50 +128,22 @@ defmodule ABI.FunctionSelector do
 
   defp parse_specification_type(%{"type" => type}), do: decode_type(type)
 
-  @doc false
-  def decode_type(full_type) do
-    cond do
-      # Check for array type
-      captures = Regex.named_captures(~r/(?<type>[a-z0-9]+)\[(?<element_count>\d*)\]/, full_type) ->
-        type = decode_type(captures["type"])
-
-        if captures["element_count"] != "" do
-          {element_count, ""} = Integer.parse(captures["element_count"])
-
-          {:array, type, element_count}
-        else
-          {:array, type}
-        end
-      # Check for tuples
-      captures = Regex.named_captures(~r/\((?<types>[a-z0-9\[\]]+,?)+\)/, full_type) ->
-        types =
-          String.split(captures["types"], ",", trim: true)
-          |> Enum.map(fn type -> decode_type(type) end)
-
-        {:tuple, types}
-      true ->
-        decode_single_type(full_type)
-    end
-  end
+  @doc """
+  Decodes the given type-string as a single type.
 
-  @doc false
-  def decode_single_type("uint" <> size_str) do
-    size = case size_str do
-      "" -> 256 # default
-      _ ->
-        {size, ""} = Integer.parse(size_str)
+  ## Examples
 
-        size
-    end
+      iex> ABI.FunctionSelector.decode_type("uint256")
+      {:uint, 256}
 
-    {:uint, size}
-  end
+      iex> ABI.FunctionSelector.decode_type("(bool,address)")
+      {:tuple, [:bool, :address]}
 
-  def decode_single_type("bool"), do: :bool
-  def decode_single_type("string"), do: :string
-  def decode_single_type("address"), do: :address
-  def decode_single_type(els) do
-    raise "Unsupported type: #{els}"
+      iex> ABI.FunctionSelector.decode_type("address[][3]")
+      {:array, {:array, :address}, 3}
+  """
+  def decode_type(single_type) do
+    ABI.Parser.parse!(single_type, as: :type)
   end
 
   @doc """

lib/abi/parser.ex

@@ -0,0 +1,21 @@
+defmodule ABI.Parser do
+  @moduledoc false
+
+  @doc false
+  def parse!(str, opts \\ []) do
+    {:ok, tokens, _} = str |> String.to_charlist |> :ethereum_abi_lexer.string
+
+    tokens = case opts[:as] do
+      nil -> tokens
+      :type -> [{:"expecting type", 1} | tokens]
+      :selector -> [{:"expecting selector", 1} | tokens]
+    end
+
+    {:ok, ast} = :ethereum_abi_parser.parse(tokens)
+
+    case ast do
+      {:type, type} -> type
+      {:selector, selector_parts} -> struct!(ABI.FunctionSelector, selector_parts)
+    end
+  end
+end

mix.exs

@@ -3,7 +3,7 @@ defmodule ABI.Mixfile do
 
   def project do
     [app: :abi,
-     version: "0.1.8",
+     version: "0.1.9",
       elixir: "~> 1.4",
       description: "Ethereum's ABI Interface",
       package: [

src/ethereum_abi_lexer.xrl

@@ -0,0 +1,21 @@
+Definitions.
+
+INT        = [0-9]+
+LETTERS    = [a-z_]+
+WHITESPACE = [\s\t\n\r]
+TYPES      = uint|int|address|bool|fixed|uint|ufixed|bytes|function|string
+
+Rules.
+
+{TYPES}       : {token, {atom,       TokenLine, list_to_atom(TokenChars)}}.
+{INT}         : {token, {int,        TokenLine, list_to_integer(TokenChars)}}.
+{LETTERS}     : {token, {binary,     TokenLine, list_to_binary(TokenChars)}}.
+\[            : {token, {'[',        TokenLine}}.
+\]            : {token, {']',        TokenLine}}.
+\(            : {token, {'(',        TokenLine}}.
+\)            : {token, {')',        TokenLine}}.
+,             : {token, {',',        TokenLine}}.
+->            : {token, {'->',       TokenLine}}.
+{WHITESPACE}+ : skip_token.
+
+Erlang code.

src/ethereum_abi_parser.yrl

@@ -0,0 +1,72 @@
+Terminals '(' ')' '[' ']' ',' '->' int atom binary 'expecting selector' 'expecting type'.
+Nonterminals dispatch selector nontrivial_selector comma_delimited_types type_with_subscripts array_subscripts tuple array_subscript identifier type typespec.
+Rootsymbol dispatch.
+
+dispatch -> 'expecting type' type_with_subscripts : {type, '$2'}.
+dispatch -> 'expecting selector' selector : {selector, '$2'}.
+dispatch -> type_with_subscripts : {selector, #{function => nil, types => ['$1'], returns => nil}}.
+dispatch -> nontrivial_selector : {selector, '$1'}.
+
+selector -> typespec : #{function => nil, types => '$1', returns => nil}.
+selector -> nontrivial_selector : '$1'.
+
+nontrivial_selector -> typespec '->' type : #{function => nil, types => '$1', returns => '$3'}.
+nontrivial_selector -> identifier typespec : #{function => '$1', types => '$2', returns => nil}.
+nontrivial_selector -> identifier typespec '->' type : #{function => '$1', types => '$2', returns => '$4'}.
+
+typespec -> '(' ')' : [].
+typespec -> '(' comma_delimited_types ')' : '$2'.
+
+tuple -> '(' ')' : {tuple, []}.
+tuple -> '(' comma_delimited_types ')' : {tuple, '$2'}.
+
+comma_delimited_types -> type_with_subscripts : ['$1'].
+comma_delimited_types -> type_with_subscripts ',' comma_delimited_types : ['$1' | '$3'].
+
+identifier -> atom : atom_to_list(v('$1')).
+identifier -> binary : v('$1').
+
+type_with_subscripts -> type : '$1'.
+type_with_subscripts -> type array_subscripts : with_subscripts('$1', '$2').
+
+array_subscripts -> array_subscript : ['$1'].
+array_subscripts -> array_subscript array_subscripts : ['$1' | '$2'].
+
+array_subscript -> '[' ']' : variable.
+array_subscript -> '[' int ']' : v('$2').
+
+type -> atom :
+  plain_type(v('$1')).
+type -> atom int :
+  juxt_type(v('$1'), v('$2')).
+type -> atom int identifier int :
+  double_juxt_type(v('$1'), v('$4'), v('$2'), v('$3')).
+type -> tuple : '$1'.
+
+
+Erlang code.
+
+v({_Token, _Line, Value}) -> Value.
+
+plain_type(address) -> address;
+plain_type(bool) -> bool;
+plain_type(function) -> function;
+plain_type(string) -> string;
+plain_type(bytes) -> bytes;
+plain_type(int) -> juxt_type(int, 256);
+plain_type(uint) -> juxt_type(uint, 256);
+plain_type(fixed) -> double_juxt_type(fixed, "x", 128, 19);
+plain_type(ufixed) -> double_juxt_type(ufixed, "x", 128, 19).
+
+with_subscripts(Type, []) -> Type;
+with_subscripts(Type, [H | T]) -> with_subscripts(with_subscript(Type, H), T).
+
+with_subscript(Type, variable) -> {array, Type};
+with_subscript(Type, N) when is_integer(N), N >= 0 -> {array, Type, N}.
+
+juxt_type(int, M) when M > 0, M =< 256, (M rem 8) =:= 0 -> {int, M};
+juxt_type(uint, M) when M > 0, M =< 256, (M rem 8) =:= 0 -> {uint, M};
+juxt_type(bytes, M) when M > 0, M =< 32 -> {bytes, M}.
+
+double_juxt_type(fixed, "x", M, N) when M >= 0, M =< 256, (M rem 8) =:= 0, N > 0, N =< 80 -> {fixed, M, N};
+double_juxt_type(ufixed, "x", M, N) when M >= 0, M =< 256, (M rem 8) =:= 0, N > 0, N =< 80 -> {ufixed, M, N}.