feat: add yecc backend

Author: thomas9911

bench/decode.exs

@@ -10,20 +10,11 @@ medium  = File.read!("./bench/data.json")
 Benchee.run(
   %{
     "jason" => fn input -> Jason.decode!(input) end,
-    "json5" => fn input -> Json5.decode!(input) end
+    "json5 combine" => fn input -> Json5.decode!(input, backend: Json5.Decode.Backend.Combine) end,
+    "json5 yecc" => fn input -> Json5.decode!(input, backend: Json5.Decode.Backend.Yecc) end,
   },
   inputs: %{
     "Small" => small,
     "Medium" => medium
   }
 )
-
-
-# Benchee.run(
-#   %{
-#     "json5" => fn input -> Json5.decode!(input) end
-#   },
-#   inputs: %{
-#     "Medium" => medium
-#   }
-# )

lib/json5/decode.ex

@@ -4,10 +4,14 @@ defmodule Json5.Decode do
   """
 
   def parse(input, config \\ %{}) do
-    backend().parse(input, config)
+    backend(config).parse(input, config)
   end
 
-  defp backend do
+  defp backend(%{backend: backend}) do
+    backend
+  end
+
+  defp backend(_) do
     Json5.Decode.Backend.Combine
   end
 end

lib/json5/decode/backend/yecc.ex

@@ -0,0 +1,72 @@
+defmodule Json5.Decode.Backend.Yecc do
+  @moduledoc """
+  Decode Json5 string to Elixir term
+
+  Does not support unicode map keys
+  """
+
+  import Json5.ECMA
+
+  alias Json5.Error
+
+  def parse(input, config \\ %{}) do
+    with {:ok, tokens, _} <-
+           input
+           |> String.to_charlist()
+           |> :lexer.string(),
+         {:ok, ast} <- :parser.parse(tokens) do
+      {:ok, to_term(ast, config)}
+    end
+  rescue
+    e in Error -> {:error, e}
+  end
+
+  defp to_term({:string, _, charlist}, _) do
+    charlist
+    |> :string.replace([92, 13, 10], [])
+    |> :string.replace([92, 10], [])
+    |> :erlang.iolist_to_binary()
+  end
+
+  defp to_term({:key, _, charlist}, config) do
+    key = List.to_string(charlist)
+
+    if is_reserved_word(key),
+      do: raise(Error, %{type: :reserved_key, input: key})
+
+    do_key_term(key, config)
+  end
+
+  defp to_term({:map, _, key_value_list}, config) do
+    Map.new(key_value_list, fn {key, value} ->
+      {to_term(key, config), to_term(value, config)}
+    end)
+  end
+
+  defp to_term({:list, _, list}, config) do
+    Enum.map(list, &to_term(&1, config))
+  end
+
+  defp to_term({:null, _, nil}, _), do: nil
+  defp to_term({:boolean, _, boolean}, _), do: boolean
+
+  defp to_term({:hex_number, _, integer}, _) do
+    Decimal.new(integer)
+  end
+
+  defp to_term({:number, _, charlist}, _) do
+    charlist
+    |> List.to_string()
+    |> Decimal.new()
+  end
+
+  def do_key_term(key, %{object_key_existing_atom: true}) do
+    String.to_existing_atom(key)
+  end
+
+  def do_key_term(key, %{object_key_function: object_key_function}) do
+    object_key_function.(key)
+  end
+
+  def do_key_term(key, _), do: key
+end

lib/json5/encode.ex

@@ -6,8 +6,8 @@ defmodule Json5.Encode do
   require Json5.ECMA
 
   alias Json5.Encode.Array
-  alias Json5.Encode.Error
   alias Json5.Encode.Object
+  alias Json5.Error
 
   defguardp is_to_string(input)
             when input in [true, false] or is_float(input) or is_integer(input) or

lib/json5/encode/error.ex lib/json5/error.ex

@@ -1,20 +1,22 @@
-defmodule Json5.Encode.Error do
+defmodule Json5.Error do
   defexception [:type, :input]
 
   @impl true
   def exception(%{type: type, input: input}) do
     case type do
       :invalid_input -> :ok
+      :reserved_key -> :ok
       _ -> raise ArgumentError
     end
 
     %__MODULE__{type: type, input: input}
   end
 
   @impl true
-  def message(%__MODULE__{type: type}) do
+  def message(%__MODULE__{type: type, input: input}) do
     case type do
       :invalid_input -> "unable to format input"
+      :reserved_key -> "found a reserved word, '#{input}'"
       _ -> "something went wrong"
     end
   end

src/lexer.xrl

@@ -0,0 +1,48 @@
+Definitions.
+Digit = [0-9]
+HexDigit = [0-9a-fA-F]
+Float = (\+|-)?{Digit}+\.?{Digit}+?((E|e)(\+|-)?{Digit}+)?
+FloatNoLeadingZero = (\+|-)?\.{Digit}+((E|e)(\+|-)?{Digit}+)?
+HexDigits = 0(x|X){HexDigit}+
+DoubleQuoteString     = "(\\\^.|\\.|[^\"])*"
+SingleQuoteString     = '(\\\^.|\\.|[^\'])*'
+Key  = [a-zA-Z\_\$](\\\^.|\\.|[a-zA-Z0-9\_\$])*
+
+Rules.
+
+{Digit}+ : {token,{number,TokenLine,TokenChars}}.
+
+{Float} :  {token, {number, TokenLine, TokenChars}}.
+{FloatNoLeadingZero} :  {token, {number, TokenLine, TokenChars}}.
+{HexDigits} : {token, {hex_number, TokenLine, parse_hex(TokenChars)}}.
+
+null : {token, {null, TokenLine, nil}}.
+true : {token, {boolean, TokenLine, true}}.
+false : {token, {boolean, TokenLine, false}}.
+
+{DoubleQuoteString} : {token, {string, TokenLine, strip_quotes(TokenChars)}}.
+{SingleQuoteString} : {token, {string, TokenLine, strip_quotes(TokenChars)}}.
+{Key}               : {token, {key, TokenLine, TokenChars}}.
+
+\[ : {token, {open_list, TokenLine}}.
+\] : {token, {close_list, TokenLine}}.
+\{ : {token, {open_map, TokenLine}}.
+\} : {token, {close_map, TokenLine}}.
+\, : {token, {sep, TokenLine}}.
+\: : {token, {key_value_sep, TokenLine}}.
+
+%% white space
+[\s\n\r\t]+           : skip_token.
+%% line comment
+//[^\n]*               : skip_token.
+%% multiline comment
+/\*[^(*/)]*\*/         : skip_token.
+
+
+
+Erlang code.
+strip_quotes(Str) ->
+    tl(lists:droplast(Str)).
+
+parse_hex(Str) ->
+    list_to_integer(tl(tl(Str)), 16).

src/parser.yrl

@@ -0,0 +1,33 @@
+Nonterminals term factor seq_items key_value_items key_index key_value.
+Terminals number hex_number open_list close_list open_map close_map null boolean string key sep key_value_sep.
+Rootsymbol term.
+
+term -> factor : '$1'.
+
+factor -> open_list close_list : {list, line('$1'), []}.
+factor -> open_list seq_items close_list : {list, line('$1'), '$2'}.
+factor -> open_map close_map : {map, line('$1'), []}.
+factor -> open_map key_value_items close_map : {map, line('$1'), '$2'}.
+
+factor -> number : '$1'.
+factor -> string : '$1'.
+factor -> null : '$1'.
+factor -> boolean : '$1'.
+factor -> hex_number: '$1'.
+
+seq_items -> term : ['$1'].
+seq_items -> term sep : ['$1'].
+seq_items -> term sep seq_items : ['$1'|'$3'].
+key_value_items -> key_value : ['$1'].
+key_value_items -> key_value sep : ['$1'].
+key_value_items -> key_value sep key_value_items : ['$1'|'$3'].
+key_value -> key_index key_value_sep term : {'$1', '$3'}.
+
+key_index -> key : '$1'.
+key_index -> string : '$1'.
+
+Erlang code.
+
+line(T) when is_tuple(T) -> element(2, T);
+line([H|_T]) -> element(2, H);
+line(T) -> ct:print("WAT ~p", [T]).