couchemar/wa_parser - Change ZR7U7TRCUHXMBXQFA3XXNGJPPYFACMOWPQKGUH7E22KGFM35HSNAC

Parser as a interpreter

Created by couchemar on June 18, 2021

ZR7U7TRCUHXMBXQFA3XXNGJPPYFACMOWPQKGUH7E22KGFM35HSNAC

Dependencies

In channels

main

Change contents

Replacement in lib/wa_parser.ex at line 6 [5.693]

B:BD[3.1] → [4.0:24]

  defstruct parsers: []

[3.1]

[5.771]

  defstruct parsers: [], tags: [], stop: false, acc: []

Replacement in lib/wa_parser.ex at line 13 [5.693]

B:BD[2.110] → [2.110:163]

        s(:type_section, section([bytes(<<0x01>>)]))

[2.110]

[4.123]

        s(
          :type_section,
          section([
            s(:id, bytes(<<0x01>>))
          ])
        )

Replacement in lib/wa_parser.ex at line 28 [5.693]

B:BD[4.266] → [4.266:308]

    {{:error, :no_parsers}, state, chunk}

[4.266]

[4.308]

    state = %{state | stop: true}
    {state, chunk}

Replacement in lib/wa_parser.ex at line 33 [5.693]

∅:D[2.245] → [4.403:452]

B:BD[4.403] → [4.403:452]

B:BD[4.452] → [2.246:302]

    case parser.(chunk) do
      :not_matched ->
        {{:error, {:not_matched, chunk}}, state, chunk}

[2.245]

[6.237]

    results = parser.(chunk)
    new_state = %{state | parsers: rest_parsers}
    for result <- results, reduce: {new_state, chunk} do
      {state, chunk} ->
        case result do
          {:add_tag, tag} ->
            {%{state | tags: [tag | state.tags]}, chunk}
          {:cont, cont} ->
            {%{state | parsers: [cont | state.parsers]}, chunk}
          {:add_acc, result, tail} ->
            {%{state | acc: [result | state.acc]}, tail}

Replacement in lib/wa_parser.ex at line 49 [5.693]

B:BD[6.238] → [4.514:579]

      :need_more ->
        {{:error, :need_more}, state, chunk}

[6.238]

[6.411]

          {:add_acc, result} ->
            {%{state | acc: [result | state.acc]}, chunk}

Replacement in lib/wa_parser.ex at line 52 [5.693]

B:BD[6.412] → [2.303:419]

      :section_end ->
        new_state = %{state | parsers: rest_parsers}
        {:section_end, new_state, chunk}

[6.412]

[2.419]

          :keep_result ->
            [last | acc] = state.acc

Replacement in lib/wa_parser.ex at line 55 [5.693]

B:BD[2.420] → [2.420:452]

∅:D[2.452] → [4.612:665]

B:BD[4.612] → [4.612:665]

B:BD[4.665] → [2.453:492]

      {tag, data, tail, nil} ->
        new_state = %{state | parsers: rest_parsers}
        {{tag, data}, new_state, tail}

[2.420]

[2.492]

            {new_acc, new_tags} =
              case state.tags do
                [tag] -> {[{tag, last} | acc], []}
                [_tag | rest_tags] = tags -> {[{tags |> Enum.reverse(), last} | acc], rest_tags}
              end

Replacement in lib/wa_parser.ex at line 61 [5.693]

B:BD[2.493] → [2.493:602]

∅:D[2.602] → [4.665:704]

B:BD[4.665] → [4.665:704]

      {tag, data, tail, next_parser} ->
        new_state = %{state | parsers: [next_parser | rest_parsers]}
        {{tag, data}, new_state, tail}

[2.493]

[4.704]

            {%{state | tags: new_tags, acc: new_acc}, chunk}
        end

Replacement in lib/wa_parser.ex at line 67 [5.693]
B:BD[4.752] → [4.752:790]
```
    parse_all(chunk, state, [])
  end
```
[4.752]
[3.566]
```
    {state, tail} = parse_one(chunk, state)
```

Replacement in lib/wa_parser.ex at line 69 [5.693]

B:BD[3.567] → [4.791:878]

  defp parse_all(<<>>, state, results) do
    {results |> Enum.reverse(), state, <<>>}

[3.567]

[4.878]

    if state.stop do
      {state, tail}
    else
      parse_all(tail, state)
    end

Replacement in lib/wa_parser.ex at line 76 [5.693]

B:BD[3.677] → [4.885:980]

  defp parse_all(chunk, state, results) do
    {result, state, tail} = parse_one(chunk, state)

[3.677]

[5.798]

  def get_results({state, chunk}) do
    {state.acc |> Enum.reverse(), state, chunk}
  end

Replacement in lib/wa_parser.ex at line 80 [5.693]

B:BD[5.799] → [4.981:1127]

    case result do
      {:error, _} -> {[result | results] |> Enum.reverse(), state, tail}
      _ -> parse_all(tail, state, [result | results])

[5.799]

[4.1127]

  defp s(name, cont) do
    fn _chunk ->
      [
        {:add_tag, name},
        {:cont, &keep_result/1},
        {:cont, cont}
      ]

Replacement in lib/wa_parser.ex at line 90 [5.693]

B:BD[5.814] → [2.603:785]

  defp s(name, matcher) do
    fn chunk ->
      case matcher.(chunk) do
        {:matched, chunk, tail, next_parser} ->
          {name, chunk, tail, next_parser}
      end
    end

[5.814]

[2.785]

  defp keep_result(_chunk) do
    [
      :keep_result
    ]

Deletion in lib/wa_parser.ex at line 101 [5.693]

B:BD[3.974] → [3.974:1046]

        c when :erlang.size(c) < expected_size ->
          :need_more

Replacement in lib/wa_parser.ex at line 102 [5.693]

B:BD[3.1122] → [2.793:835]

∅:D[2.835] → [3.1159:1196]

B:BD[3.1159] → [3.1159:1196]

          {:matched, expected, rest, nil}
        _ ->
          :not_matched

[3.1122]

[3.1196]

          [
            {:add_acc, expected, rest}
          ]

Replacement in lib/wa_parser.ex at line 111 [5.693]
B:BD[2.889] → [2.889:908]
```
      :section_end
```
[2.889]
[3.1206]
```
      [
        {:add_acc, :section_end}
      ]
```
Replacement in lib/wa_parser.ex at line 118 [5.693]
B:BD[2.954] → [2.954:1006]
```
    fn chunk ->
      [parser | rest_parts] = parts
```
[2.954]
[2.1006]
```
    [next | rest] = parts
```

Replacement in lib/wa_parser.ex at line 120 [5.693]

B:BD[2.1007] → [2.1007:1156]

      case parser.(chunk) do
        {:matched, expected, tail, nil} -> {:matched, expected, tail, section(rest_parts)}
        res -> res
      end

[2.1007]

[2.1156]

    fn _chunk ->
      [
        {:cont, section(rest)},
        {:cont, next}
      ]