diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index a0a11aed..cb6a18ab 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -1,5 +1,212 @@ defmodule Engine do - def ensure_all_started() do - Application.ensure_all_started(:engine) + @moduledoc """ + The remote control boots another elixir application in a separate VM, injects + the remote control application into it and allows the language server to execute tasks in the + context of the remote VM. + """ + + alias Forge.Project + + alias Engine.Api.Proxy + alias Forge.CodeAction + alias Forge.CodeIntelligence + alias Engine.ProjectNode + + require Logger + + @excluded_apps [:patch, :nimble_parsec] + @allowed_apps [:remote_control | Mix.Project.deps_apps()] -- @excluded_apps + + defdelegate schedule_compile(force?), to: Proxy + + defdelegate compile_document(document), to: Proxy + + defdelegate format(document), to: Proxy + + defdelegate reindex, to: Proxy + + defdelegate index_running?, to: Proxy + + defdelegate broadcast(message), to: Proxy + + defdelegate expand_alias(segments_or_module, analysis, position), to: Forge.Analyzer + + defdelegate list_modules, to: :code, as: :all_available + + defdelegate code_actions(document, range, diagnostics, kinds), to: CodeAction, as: :for_range + + defdelegate complete(env), to: Engine.Completion, as: :elixir_sense_expand + + defdelegate complete_struct_fields(analysis, position), + to: Engine.Completion, + as: :struct_fields + + defdelegate definition(document, position), to: CodeIntelligence.Definition + + defdelegate references(analysis, position, include_definitions?), + to: CodeIntelligence.References + + defdelegate modules_with_prefix(prefix), to: Forge.Modules, as: :with_prefix + + defdelegate modules_with_prefix(prefix, predicate), to: Forge.Modules, as: :with_prefix + + defdelegate docs(module, opts \\ []), to: CodeIntelligence.Docs, as: :for_module + + defdelegate register_listener(listener_pid, message_types), to: Forge.Dispatch + + defdelegate resolve_entity(analysis, position), to: CodeIntelligence.Entity, as: :resolve + + defdelegate struct_definitions, to: CodeIntelligence.Structs, as: :for_project + + defdelegate document_symbols(document), to: CodeIntelligence.Symbols, as: :for_document + + defdelegate workspace_symbols(query), to: CodeIntelligence.Symbols, as: :for_workspace + + def start_link(%Project{} = project) do + :ok = ensure_epmd_started() + start_net_kernel(project) + + apps_to_start = [:elixir | @allowed_apps] ++ [:runtime_tools] + node = Project.node_name(project) + + with {:ok, node_pid} <- ProjectNode.start(project, glob_paths()), + :ok <- ensure_apps_started(node, apps_to_start) do + {:ok, node, node_pid} + end + end + + def with_lock(lock_type, func) do + :global.trans({lock_type, self()}, func, [Node.self()]) + end + + + defdelegate stop(project), to: ProjectNode + + def manager_node_name(%Project{} = project) do + :"manager-#{Project.name(project)}-#{Project.entropy(project)}@127.0.0.1" + end + + defp start_net_kernel(%Project{} = project) do + manager = manager_node_name(project) + :net_kernel.start(manager, %{name_domain: :longnames}) + end + + defp ensure_apps_started(node, app_names) do + Enum.reduce_while(app_names, :ok, fn app_name, _ -> + case :rpc.call(node, :application, :ensure_all_started, [app_name]) do + {:ok, _} -> {:cont, :ok} + error -> {:halt, error} + end + end) + end + + defp glob_paths do + for entry <- :code.get_path(), + entry_string = List.to_string(entry), + entry_string != ".", + Enum.any?(app_globs(), &PathGlob.match?(entry_string, &1, match_dot: true)) do + entry + end + end + + def elixir_executable(%Project{} = project) do + root_path = Project.root_path(project) + + {path_result, env} = + with nil <- version_manager_path_and_env("asdf", root_path), + nil <- version_manager_path_and_env("mise", root_path), + nil <- version_manager_path_and_env("rtx", root_path) do + {File.cd!(root_path, fn -> System.find_executable("elixir") end), System.get_env()} + end + + case path_result do + nil -> + {:error, :no_elixir} + + executable when is_binary(executable) -> + {:ok, executable, env} + end + end + + defp app_globs do + app_globs = Enum.map(@allowed_apps, fn app_name -> "/**/#{app_name}*/ebin" end) + ["/**/priv" | app_globs] + end + + defp ensure_epmd_started do + case System.cmd("epmd", ~w(-daemon)) do + {"", 0} -> + :ok + + _ -> + {:error, :epmd_failed} + end + end + + defp version_manager_path_and_env(manager, root_path) do + with true <- is_binary(System.find_executable(manager)), + env = reset_env(manager, root_path), + {path, 0} <- System.cmd(manager, ~w(which elixir), cd: root_path, env: env) do + {String.trim(path), env} + else + _ -> + nil + end + end + + # We launch lexical by asking the version managers to provide an environment, + # which contains path munging. This initial environment is present in the running + # VM, and needs to be undone so we can find the correct elixir executable in the project. + defp reset_env("asdf", _root_path) do + orig_path = System.get_env("PATH_SAVE", System.get_env("PATH")) + + Enum.map(System.get_env(), fn + {"ASDF_ELIXIR_VERSION", _} -> {"ASDF_ELIXIR_VERSION", nil} + {"ASDF_ERLANG_VERSION", _} -> {"ASDF_ERLANG_VERSION", nil} + {"PATH", _} -> {"PATH", orig_path} + other -> other + end) + end + + defp reset_env("rtx", root_path) do + {env, _} = System.cmd("rtx", ~w(env -s bash), cd: root_path) + + env + |> String.trim() + |> String.split("\n") + |> Enum.map(fn + "export " <> key_and_value -> + [key, value] = + key_and_value + |> String.split("=", parts: 2) + |> Enum.map(&String.trim/1) + + {key, value} + + _ -> + nil + end) + |> Enum.reject(&is_nil/1) + end + + defp reset_env("mise", root_path) do + {env, _} = System.cmd("mise", ~w(env -s bash), cd: root_path) + + env + |> String.trim() + |> String.split("\n") + |> Enum.map(fn + "export " <> key_and_value -> + [key, value] = + key_and_value + |> String.split("=", parts: 2) + |> Enum.map(&String.trim/1) + + {key, value} + + _ -> + nil + end) + |> Enum.reject(&is_nil/1) end end diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex new file mode 100644 index 00000000..ad144587 --- /dev/null +++ b/engine/lib/engine/api/proxy.ex @@ -0,0 +1,247 @@ +defmodule Engine.Api.Proxy do + @moduledoc """ + A bimodal buffering proxy + + This proxy has two modes. In its default mode, it simply forwards function calls to another module, but when + buffering is activated, it will buffer requests and returned canned responses. + When a process calls `start_buffering`, it is monitored, and while it's alive, all messages are buffered. When the + process that calls `start_buffering` exits, the messages that are buffered then have the potential to be emitted. + + Buffered request are subject to the proxy's internal logic. Some requests that are time sensitive + (like formatting) are dropped. Others are deduplicated, while others are reordered. + + The logic follows below + `broadcast` - Buffered - Though, those related to other events, like compilation are subject to + the rules that govern their source events. Progress messages are sent regardless of + buffering. + `schedule_compile` - Buffered - Only one call is kept + `compile_document` - Buffered, though only one call per URI is kept, and if a `schedule_compile` call + was buffered, all `compile_document` calls are dropped + `reindex` - Buffered, though only one call is kept and it is the last thing run. + `index_running?` - Dropped because it requires an immediate response + `format` - Dropped, as it requires an immediate response. Responds immediately with empty changes + + Internally, there are three states: proxying, draining and buffering. + The proxy starts in proxying mode. Then, when start_buffering is called, it changes to draining mode. This + mode checks if there are any in-flight calls. If there aren't any, it changes immediately to buffring mode. + If there are in-flight reqeusts, it waits for them to finish, and then switches to buffer mode. Once in buffer + mode, requests are buffered until the process that called `start_buffering` exits. When that happens, then + the requests are de-duplicated and run, and then the proxy returns to proxying mode. + + """ + + alias Forge.Document + alias Forge.Document.Changes + + alias Forge.Api.Messages + alias Engine.Api.Proxy.BufferingState + alias Engine.Api.Proxy.DrainingState + alias Engine.Api.Proxy.ProxyingState + alias Engine.Api.Proxy.Records + alias Forge.CodeMod + alias Engine.Commands + + import Messages + import Record + import Records, only: :macros + + @behaviour :gen_statem + + defrecord :buffer, contents: nil, return: :ok + defrecord :drop, contents: nil, return: :ok + + # public API + + def start_buffering do + start_buffering(self()) + end + + def start_buffering(caller) when is_pid(caller) do + :gen_statem.call(__MODULE__, {:start_buffering, caller}) + end + + # proxied functions + + def broadcast(percent_progress() = message) do + Forge.Dispatch.broadcast(message) + end + + def broadcast(message) do + mfa = to_mfa(Forge.Dispatch.broadcast(message)) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def schedule_compile(force? \\ false) do + project = Forge.get_project() + + mfa = to_mfa(Engine.Build.schedule_compile(project, force?)) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def compile_document(document) do + project = Forge.get_project() + + mfa = to_mfa(Engine.Build.compile_document(project, document)) + + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def reindex do + mfa = to_mfa(Commands.Reindex.perform()) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def index_running? do + mfa = to_mfa(Commands.Reindex.running?()) + :gen_statem.call(__MODULE__, drop(contents: mfa, return: false)) + end + + def format(%Document{} = document) do + mfa = to_mfa(CodeMod.Format.edits(document)) + drop = drop(contents: mfa, return: {:ok, Changes.new(document, [])}) + :gen_statem.call(__MODULE__, drop) + end + + # utility functions + + def buffering? do + :gen_statem.call(__MODULE__, :buffering?) + end + + # :gen_statem callbacks + def start_link do + :gen_statem.start_link({:local, __MODULE__}, __MODULE__, [], []) + end + + @impl :gen_statem + def init(_) do + {:ok, :proxying, ProxyingState.new()} + end + + def child_spec(_) do + %{ + id: __MODULE__, + start: {__MODULE__, :start_link, []} + } + end + + @impl :gen_statem + def callback_mode, do: :state_functions + + # callbacks for proxying mode + + def proxying({:call, from}, {:start_buffering, caller}, %ProxyingState{} = state) do + Process.monitor(caller) + buffering_state = BufferingState.new(caller) + + if ProxyingState.empty?(state) do + {:next_state, :buffering, buffering_state, {:reply, from, :ok}} + else + draining_state = DrainingState.new(buffering_state, state) + {:next_state, :draining, draining_state, {:reply, from, :ok}} + end + end + + def proxying({:call, from}, buffer(contents: contents), %ProxyingState{} = state) do + state = ProxyingState.apply_mfa(state, from, contents) + + {:keep_state, state} + end + + def proxying({:call, from}, drop(contents: contents), state) do + state = ProxyingState.apply_mfa(state, from, contents) + {:keep_state, state} + end + + def proxying({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, false}} + end + + def proxying(:info, {ref, reply}, %ProxyingState{} = state) when is_reference(ref) do + ProxyingState.reply(state, ref, reply) + {:keep_state, state} + end + + def proxying(:info, {:DOWN, ref, _, _, _}, %ProxyingState{} = state) do + # Handle the DOWN from the task + new_state = ProxyingState.consume_reply(state, ref) + {:keep_state, new_state} + end + + # Callbacks for the draining mode + + def draining(:info, {ref, reply}, %DrainingState{} = state) when is_reference(ref) do + DrainingState.reply(state, ref, reply) + + {:keep_state, state} + end + + def draining({:call, from}, {:start_buffering, _}, %DrainingState{} = state) do + initiator_pid = state.buffering_state.initiator_pid + {:keep_state, state, {:reply, from, {:error, {:already_buffering, initiator_pid}}}} + end + + def draining( + {:call, from}, + buffer(contents: mfa() = mfa, return: return), + %DrainingState{} = state + ) do + state = DrainingState.add_mfa(state, mfa) + {:keep_state, state, {:reply, from, return}} + end + + def draining({:call, from}, drop(return: return), %DrainingState{} = state) do + {:keep_state, state, {:reply, from, return}} + end + + def draining({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, true}} + end + + def draining(:info, {:DOWN, ref, _, _, _}, %DrainingState{} = state) do + new_state = DrainingState.consume_reply(state, ref) + + if DrainingState.drained?(new_state) do + {:next_state, :buffering, state.buffering_state} + else + {:keep_state, state} + end + end + + # Callbacks for buffering mode + + def buffering({:call, from}, {:start_buffering, _}, %BufferingState{} = state) do + {:keep_state, state, {:reply, from, {:error, {:already_buffering, state.initiator_pid}}}} + end + + def buffering( + {:call, from}, + buffer(contents: mfa() = mfa, return: return), + %BufferingState{} = state + ) do + state = BufferingState.add_mfa(state, mfa) + {:keep_state, state, {:reply, from, return}} + end + + def buffering({:call, from}, drop(return: return), %BufferingState{} = state) do + {:keep_state, state, {:reply, from, return}} + end + + def buffering(:info, {:DOWN, _, :process, pid, _}, %BufferingState{initiator_pid: pid} = state) do + state + |> BufferingState.flush() + |> Enum.each(&apply/1) + + {:next_state, :proxying, ProxyingState.new()} + end + + def buffering({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, true}} + end + + # Private + + defp apply(mfa(module: module, function: function, arguments: arguments)) do + apply(module, function, arguments) + end +end diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex new file mode 100644 index 00000000..2189d186 --- /dev/null +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -0,0 +1,146 @@ +defmodule Engine.Api.Proxy.BufferingState do + alias Forge.Document + + alias Engine.Api + alias Engine.Build + alias Engine.Commands + + import Forge.Api.Messages + import Api.Proxy.Records + + defstruct initiator_pid: nil, buffer: [] + + def new(initiator_pid) do + %__MODULE__{initiator_pid: initiator_pid} + end + + def add_mfa(%__MODULE__{} = state, mfa() = mfa_record) do + %__MODULE__{state | buffer: [mfa_record | state.buffer]} + end + + def flush(%__MODULE__{} = state) do + {messages, commands} = + state.buffer + |> Enum.reverse() + |> Enum.split_with(fn value -> + match?(mfa(module: Forge.Dispatch, function: :broadcast), value) + end) + + {project_compile, document_compiles, reindex} = collapse_commands(commands) + + all_commands = [project_compile | Map.values(document_compiles)] + + all_commands + |> Enum.concat(collapse_messages(messages, project_compile, document_compiles)) + |> Enum.filter(&match?(mfa(), &1)) + |> Enum.sort_by(fn mfa(seq: seq) -> seq end) + |> then(fn commands -> + if reindex do + commands ++ [reindex] + else + commands + end + end) + end + + defp collapse_commands(commands) do + # Rules for collapsing commands + # 1. If there's a project compilation requested, remove all document compilations + # 2. Formats can be dropped, as they're only valid for a short time. + # 3. If there's a reindex, do it after the project compilation has finished + + initial_state = %{project_compiles: [], document_compiles: %{}, reindex: nil} + + grouped = + commands + |> Enum.reduce( + initial_state, + fn + mfa(module: Build, function: :schedule_compile) = mfa, acc -> + Map.update(acc, :project_compiles, [mfa], &[mfa | &1]) + + mfa(module: Build, function: :compile_document) = mfa, acc -> + mfa(arguments: [_, document]) = mfa + uri = document.uri + put_in(acc, [:document_compiles, uri], mfa) + + mfa(module: Commands.Reindex) = mfa, acc -> + Map.put(acc, :reindex, mfa) + + _, acc -> + acc + end + ) + + %{ + project_compiles: project_compiles, + document_compiles: document_compiles, + reindex: reindex + } = grouped + + project_compile = + Enum.reduce(project_compiles, nil, fn + mfa(arguments: [_, true]) = mfa, _ -> + mfa + + mfa(arguments: [true]) = mfa, _ -> + mfa + + mfa() = mfa, nil -> + mfa + + _, acc -> + acc + end) + + document_compiles = + if project_compile do + %{} + else + for {uri, indexed} <- document_compiles, Document.Store.open?(uri), into: %{} do + {uri, indexed} + end + end + + {project_compile, document_compiles, reindex} + end + + defp collapse_messages(messages, project_compile, document_compiles) do + # Rules for collapsing messages + # 1. If the message is document-centric, discard it if the document isn't open. + # 2. It's probably safe to drop all file compile requested messages + # 3. File diagnostics can be dropped if + # a. There is a document compile command for that uri + # b. There is a project compile requested + # 4. Progress messages should still be sent to dispatch, even when buffering + + Enum.filter(messages, fn + mfa(arguments: [file_compile_requested()]) -> + false + + mfa(arguments: [project_compile_requested()]) -> + false + + mfa(arguments: [file_diagnostics(uri: uri)]) -> + not (Map.has_key?(document_compiles, uri) or + match?(project_compile_requested(), project_compile)) + + mfa(arguments: [body]) -> + case fetch_uri(body) do + {:ok, uri} -> + Document.Store.open?(uri) + + :error -> + true + end + end) + end + + defp fetch_uri(filesystem_event(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_changed(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_compile_requested(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_compiled(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_deleted(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_diagnostics(uri: uri)), do: {:ok, uri} + defp fetch_uri(_), do: :error +end diff --git a/engine/lib/engine/api/proxy/draining_state.ex b/engine/lib/engine/api/proxy/draining_state.ex new file mode 100644 index 00000000..6c1b33ae --- /dev/null +++ b/engine/lib/engine/api/proxy/draining_state.ex @@ -0,0 +1,30 @@ +defmodule Engine.Api.Proxy.DrainingState do + alias Engine.Api.Proxy.BufferingState + alias Engine.Api.Proxy.ProxyingState + alias Engine.Api.Proxy.Records + + import Records + + defstruct [:proxying_state, :buffering_state] + + def new(%BufferingState{} = buffering_state, %ProxyingState{} = proxying_state) do + %__MODULE__{buffering_state: buffering_state, proxying_state: proxying_state} + end + + def drained?(%__MODULE__{} = state) do + ProxyingState.empty?(state.proxying_state) + end + + def consume_reply(%__MODULE__{} = state, ref) when is_reference(ref) do + %__MODULE__{state | proxying_state: ProxyingState.consume_reply(state.proxying_state, ref)} + end + + def reply(%__MODULE__{} = state, ref, reply) do + ProxyingState.reply(state.proxying_state, ref, reply) + end + + def add_mfa(%__MODULE__{} = state, mfa() = mfa) do + new_buffering_state = BufferingState.add_mfa(state.buffering_state, mfa) + %__MODULE__{state | buffering_state: new_buffering_state} + end +end diff --git a/engine/lib/engine/api/proxy/proxying_state.ex b/engine/lib/engine/api/proxy/proxying_state.ex new file mode 100644 index 00000000..466ac749 --- /dev/null +++ b/engine/lib/engine/api/proxy/proxying_state.ex @@ -0,0 +1,42 @@ +defmodule Engine.Api.Proxy.ProxyingState do + alias Engine.Api.Proxy.Records + + defstruct refs_to_from: %{} + + import Records + + def new do + %__MODULE__{} + end + + def apply_mfa( + %__MODULE__{} = state, + from, + mfa(module: module, function: function, arguments: arguments) + ) do + task = Task.async(module, function, arguments) + + %__MODULE__{ + state + | refs_to_from: Map.put(state.refs_to_from, task.ref, from) + } + end + + def reply(%__MODULE__{} = state, ref, reply) when is_reference(ref) do + case Map.fetch(state.refs_to_from, ref) do + {:ok, from} -> + :gen_statem.reply(from, reply) + + _ -> + :ok + end + end + + def consume_reply(%__MODULE__{} = state, ref) when is_reference(ref) do + %__MODULE__{state | refs_to_from: Map.delete(state.refs_to_from, ref)} + end + + def empty?(%__MODULE__{} = state) do + Enum.empty?(state.refs_to_from) + end +end diff --git a/engine/lib/engine/api/proxy/records.ex b/engine/lib/engine/api/proxy/records.ex new file mode 100644 index 00000000..1a9d344c --- /dev/null +++ b/engine/lib/engine/api/proxy/records.ex @@ -0,0 +1,37 @@ +defmodule Engine.Api.Proxy.Records do + alias Forge.Formats + + import Record + + defrecord :mfa, module: nil, function: nil, arguments: [], seq: nil + + def mfa(module, function, arguments) do + mfa( + module: module, + function: function, + arguments: arguments, + seq: System.unique_integer([:monotonic]) + ) + end + + defmacro to_mfa(ast) do + {m, f, a} = Macro.decompose_call(ast) + module = Macro.expand(m, __CALLER__) + arity = length(a) + + Code.ensure_compiled!(module) + Code.ensure_loaded!(module) + + unless function_exported?(module, f, arity) do + mfa = Formats.mfa(module, f, arity) + + raise CompileError.message(%{ + file: __CALLER__.file, + line: __CALLER__.line, + description: "No function named #{mfa} defined. Proxy will fail" + }) + end + + quote(do: unquote(__MODULE__).mfa(unquote(m), unquote(f), unquote(a))) + end +end diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index fd897802..3c84beff 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -1,18 +1,32 @@ defmodule Engine.Application do - # See https://hexdocs.pm/elixir/Application.html - # for more information on OTP Applications @moduledoc false use Application + require Logger @impl true def start(_type, _args) do - children = [ - Engine.Worker - ] + children = + if Forge.project_node?() do + [ + Engine.Api.Proxy, + Engine.Commands.Reindex, + Forge.Module.Loader, + {Forge.Dispatch, progress: true}, + Engine.ModuleMappings, + Engine.Build, + Engine.Build.CaptureServer, + Forge.Search.Store.Backends.Ets, + {Forge.Search.Store, + [ + &Forge.Search.Indexer.create_index/1, + &Forge.Search.Indexer.update_index/2 + ]} + ] + else + [] + end - # See https://hexdocs.pm/elixir/Supervisor.html - # for other strategies and supported options opts = [strategy: :one_for_one, name: Engine.Supervisor] Supervisor.start_link(children, opts) end diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex new file mode 100644 index 00000000..c0aa36af --- /dev/null +++ b/engine/lib/engine/bootstrap.ex @@ -0,0 +1,128 @@ +defmodule Engine.Bootstrap do + @moduledoc """ + Bootstraps the remote control node boot sequence. + + We need to first start elixir and mix, then load the project's mix.exs file so we can discover + the project's code paths, which are then added to the code paths from the language server. At this + point, it's safe to start the project, as we should have all the code present to compile the system. + """ + alias Forge.Project + + require Logger + + def init(%Project{} = project, document_store_entropy, app_configs) do + Forge.Document.Store.set_entropy(document_store_entropy) + + Application.put_all_env(app_configs) + + maybe_append_hex_path() + + project_root = Project.root_path(project) + + with :ok <- File.cd(project_root), + {:ok, _} <- Application.ensure_all_started(:elixir), + {:ok, _} <- Application.ensure_all_started(:mix), + {:ok, _} <- Application.ensure_all_started(:logger) do + project = maybe_load_mix_exs(project) + Forge.set_project(project) + Mix.env(:test) + ExUnit.start() + start_logger(project) + maybe_change_directory(project) + Project.ensure_workspace(project) + end + end + + defp maybe_append_hex_path do + hex_ebin = Path.join(["hex-*", "**", "ebin"]) + + hex_path = + :archives + |> Mix.path_for() + |> Path.join(hex_ebin) + |> Path.wildcard() + + case hex_path do + [archives] -> Code.append_path(archives) + _ -> :ok + end + end + + defp start_logger(%Project{} = project) do + log_file_name = + project + |> Project.workspace_path("project.log") + |> String.to_charlist() + + handler_name = :"#{Project.name(project)}_handler" + + config = %{ + config: %{ + file: log_file_name, + max_no_bytes: 1_000_000, + max_no_files: 1 + }, + level: :info + } + + :logger.add_handler(handler_name, :logger_std_h, config) + end + + defp maybe_change_directory(%Project{} = project) do + current_dir = File.cwd!() + + # Note about the following code: + # I tried a bunch of stuff to get it to work, like checking if the + # app is an umbrella (umbrealla? returns false when started in a subapp) + # to no avail. This was the only thing that consistently worked + {:ok, configured_root} = + Forge.Mix.in_project(project, fn _ -> + Mix.Project.config() + |> Keyword.get(:config_path) + |> Path.dirname() + |> Path.join("..") + |> Path.expand() + end) + + unless current_dir == configured_root do + File.cd!(configured_root) + end + end + + defp maybe_load_mix_exs(%Project{} = project) do + # The reason this function exists is to support projects that have the same name as + # one of their dependencies. Prior to this, the project name was based off the directory + # name of the project, and if that's the same as a dependency, the mix project stack will + # raise an error during `deps.safe_compile`, as a project with the same name was already defined. + # Mix itself uses the name of the module that the mix.exs defines as the project name, and I figured + # this was a safe default. + + with path when is_binary(path) <- Project.mix_exs_path(project), + compiled = Code.compile_file(path), + {:ok, project_module} <- find_mix_project_module(compiled) do + # We've found the mix project module, but it's now been added to the + # project stack. We need to clear the stack because we use `in_mix_project`, and + # that will fail if the current project is already in the project stack. + # Restarting mix will clear the stack without using private APIs. + Application.stop(:mix) + Application.ensure_all_started(:mix) + Project.set_project_module(project, project_module) + else + _ -> + project + end + end + + defp find_mix_project_module(module_list) do + case Enum.find(module_list, &project_module?/1) do + {module, _bytecode} -> {:ok, module} + nil -> :error + end + end + + defp project_module?({module, _bytecode}) do + function_exported?(module, :project, 0) + end + + defp project_module?(_), do: false +end diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex new file mode 100644 index 00000000..8fd8dfdc --- /dev/null +++ b/engine/lib/engine/build.ex @@ -0,0 +1,102 @@ +defmodule Engine.Build do + alias Forge.Document + alias Forge.Project + + alias Engine.Build.Document.Compilers.HEEx + alias Engine.Build.State + alias Forge.VM.Versions + + require Logger + use GenServer + + @timeout_interval_millis 50 + + # Public interface + + def path(%Project{} = project) do + %{elixir: elixir, erlang: erlang} = Versions.current() + erlang_major = erlang |> String.split(".") |> List.first() + elixir_version = Version.parse!(elixir) + elixir_major = "#{elixir_version.major}.#{elixir_version.minor}" + build_root = Project.build_path(project) + Path.join([build_root, "erl-#{erlang_major}", "elixir-#{elixir_major}"]) + end + + def schedule_compile(%Project{} = _project, force? \\ false) do + GenServer.cast(__MODULE__, {:compile, force?}) + end + + def compile_document(%Project{} = _project, %Document{} = document) do + with false <- Path.absname(document.path) == "mix.exs", + false <- HEEx.recognizes?(document) do + GenServer.cast(__MODULE__, {:compile_file, document}) + end + + :ok + end + + # this is for testing + def force_compile_document(%Document{} = document) do + with false <- Path.absname(document.path) == "mix.exs", + false <- HEEx.recognizes?(document) do + GenServer.call(__MODULE__, {:force_compile_file, document}) + end + + :ok + end + + def with_lock(func) do + Engine.with_lock(__MODULE__, func) + end + + # GenServer Callbacks + + def start_link(_) do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @impl GenServer + def init([]) do + state = State.new(Forge.get_project()) + + with :ok <- State.set_compiler_options() do + {:ok, state, {:continue, :ensure_build_directory}} + end + end + + @impl GenServer + def handle_continue(:ensure_build_directory, %State{} = state) do + State.ensure_build_directory(state) + {:noreply, state} + end + + @impl GenServer + def handle_call({:force_compile_file, %Document{} = document}, _from, %State{} = state) do + State.compile_file(state, document) + {:reply, :ok, state, @timeout_interval_millis} + end + + @impl GenServer + def handle_cast({:compile, force?}, %State{} = state) do + new_state = State.on_project_compile(state, force?) + {:noreply, new_state, @timeout_interval_millis} + end + + @impl GenServer + def handle_cast({:compile_file, %Document{} = document}, %State{} = state) do + new_state = State.on_file_compile(state, document) + {:noreply, new_state, @timeout_interval_millis} + end + + @impl GenServer + def handle_info(:timeout, %State{} = state) do + new_state = State.on_timeout(state) + {:noreply, new_state} + end + + @impl GenServer + def handle_info(msg, %Project{} = project) do + Logger.warning("Undefined message: #{inspect(msg)}") + {:noreply, project} + end +end diff --git a/engine/lib/engine/build/capture_io.ex b/engine/lib/engine/build/capture_io.ex new file mode 100644 index 00000000..9c571270 --- /dev/null +++ b/engine/lib/engine/build/capture_io.ex @@ -0,0 +1,103 @@ +defmodule Engine.Build.CaptureIO do + # Shamelessly stolen from ExUnit's CaptureIO + alias Engine.Build + + def capture_io(fun) when is_function(fun, 0) do + capture_io(:stdio, [], fun) + end + + def capture_io(device, fun) when is_atom(device) and is_function(fun, 0) do + capture_io(device, [], fun) + end + + def capture_io(input, fun) when is_binary(input) and is_function(fun, 0) do + capture_io(:stdio, [input: input], fun) + end + + def capture_io(options, fun) when is_list(options) and is_function(fun, 0) do + capture_io(:stdio, options, fun) + end + + def capture_io(device, input, fun) + when is_atom(device) and is_binary(input) and is_function(fun, 0) do + capture_io(device, [input: input], fun) + end + + def capture_io(device, options, fun) + when is_atom(device) and is_list(options) and is_function(fun, 0) do + do_capture_io(map_dev(device), options, fun) + end + + defp map_dev(:stdio), do: :standard_io + defp map_dev(:stderr), do: :standard_error + defp map_dev(other), do: other + + defp do_capture_io(:standard_io, options, fun) do + prompt_config = Keyword.get(options, :capture_prompt, true) + encoding = Keyword.get(options, :encoding, :unicode) + input = Keyword.get(options, :input, "") + + original_gl = Process.group_leader() + {:ok, capture_gl} = StringIO.open(input, capture_prompt: prompt_config, encoding: encoding) + + try do + Process.group_leader(self(), capture_gl) + do_capture_gl(capture_gl, fun) + after + Process.group_leader(self(), original_gl) + end + end + + defp do_capture_io(device, options, fun) do + input = Keyword.get(options, :input, "") + encoding = Keyword.get(options, :encoding, :unicode) + + case Build.CaptureServer.device_capture_on(device, encoding, input) do + {:ok, ref} -> + try do + result = fun.() + output = Build.CaptureServer.device_output(device, ref) + {output, result} + rescue + e -> + output = Build.CaptureServer.device_output(device, ref) + {output, {:exception, e}} + after + Build.CaptureServer.device_capture_off(ref) + end + + {:error, :no_device} -> + raise "could not find IO device registered at #{inspect(device)}" + + {:error, {:changed_encoding, current_encoding}} -> + raise ArgumentError, """ + attempted to change the encoding for a currently captured device #{inspect(device)}. + + Currently set as: #{inspect(current_encoding)} + Given: #{inspect(encoding)} + + If you need to use multiple encodings on a captured device, you cannot \ + run your test asynchronously + """ + + {:error, :input_on_already_captured_device} -> + raise ArgumentError, + "attempted multiple captures on device #{inspect(device)} with input. " <> + "If you need to give an input to a captured device, you cannot run your test asynchronously" + end + end + + defp do_capture_gl(string_io, fun) do + try do + fun.() + catch + kind, reason -> + {:ok, {_input, output}} = StringIO.close(string_io) + {output, {kind, reason}} + else + result -> + {:ok, {_input, output}} = StringIO.close(string_io) + {output, result} + end + end +end diff --git a/engine/lib/engine/build/capture_server.ex b/engine/lib/engine/build/capture_server.ex new file mode 100644 index 00000000..dabd9a62 --- /dev/null +++ b/engine/lib/engine/build/capture_server.ex @@ -0,0 +1,197 @@ +defmodule Engine.Build.CaptureServer do + @moduledoc false + @compile {:no_warn_undefined, Logger} + @timeout :infinity + @name __MODULE__ + + use GenServer + + def start_link(_opts) do + GenServer.start_link(__MODULE__, :ok, name: @name) + end + + def device_capture_on(name, encoding, input) do + GenServer.call(@name, {:device_capture_on, name, encoding, input}, @timeout) + end + + def device_output(name, ref) do + GenServer.call(@name, {:device_output, name, ref}, @timeout) + end + + def device_capture_off(ref) do + GenServer.call(@name, {:device_capture_off, ref}, @timeout) + end + + def log_capture_on(pid) do + GenServer.call(@name, {:log_capture_on, pid}, @timeout) + end + + def log_capture_off(ref) do + GenServer.call(@name, {:log_capture_off, ref}, @timeout) + end + + ## Callbacks + + def init(:ok) do + state = %{ + devices: %{}, + log_captures: %{}, + log_status: nil + } + + {:ok, state} + end + + def handle_call({:device_capture_on, name, encoding, input}, {caller, _}, config) do + capture_device(name, encoding, input, config, caller) + end + + def handle_call({:device_output, name, ref}, _from, config) do + device = Map.fetch!(config.devices, name) + {_, output} = StringIO.contents(device.pid) + total = byte_size(output) + {_pid, offset} = Map.fetch!(device.refs, ref) + output_size = total - offset + {:reply, binary_part(output, offset, output_size), config} + end + + def handle_call({:device_capture_off, ref}, _from, config) do + {:reply, :ok, release_device(ref, config)} + end + + def handle_call({:log_capture_on, pid}, _from, config) do + ref = Process.monitor(pid) + refs = Map.put(config.log_captures, ref, true) + + if map_size(refs) == 1 do + status = Logger.remove_backend(:console) + {:reply, ref, %{config | log_captures: refs, log_status: status}} + else + {:reply, ref, %{config | log_captures: refs}} + end + end + + def handle_call({:log_capture_off, ref}, _from, config) do + Process.demonitor(ref, [:flush]) + config = remove_log_capture(ref, config) + {:reply, :ok, config} + end + + def handle_info({:DOWN, ref, _, _, _}, config) do + config = remove_log_capture(ref, config) + config = release_device(ref, config) + {:noreply, config} + end + + defp capture_device(name, encoding, input, config, caller) do + case config.devices do + %{^name => device} -> + dead_refs = for {ref, {pid, _}} <- device.refs, not Process.alive?(pid), do: ref + + case dead_refs do + [] -> + capture_existing_device(name, encoding, input, config, caller) + + _ -> + config = Enum.reduce(dead_refs, config, &release_device/2) + capture_device(name, encoding, input, config, caller) + end + + %{} -> + capture_new_device(name, encoding, input, config, caller) + end + end + + defp capture_existing_device(name, encoding, input, config, caller) do + case Map.fetch!(config.devices, name) do + %{input?: input?} when input? or input != "" -> + {:reply, {:error, :input_on_already_captured_device}, config} + + %{encoding: ^encoding} = device -> + {_, output} = StringIO.contents(device.pid) + ref = Process.monitor(caller) + config = put_in(config.devices[name].refs[ref], {caller, byte_size(output)}) + {:reply, {:ok, ref}, config} + + %{encoding: other_encoding} -> + {:reply, {:error, {:changed_encoding, other_encoding}}, config} + end + end + + defp capture_new_device(name, encoding, input, config, caller) do + {:ok, pid} = StringIO.open(input, encoding: encoding) + original_pid = Process.whereis(name) + + try do + Process.unregister(name) + Process.register(pid, name) + rescue + ArgumentError -> + {:reply, {:error, :no_device}, config} + else + _ -> + ref = Process.monitor(caller) + + device = %{ + original_pid: original_pid, + pid: pid, + refs: %{ref => {caller, 0}}, + encoding: encoding, + input?: input != "" + } + + {:reply, {:ok, ref}, put_in(config.devices[name], device)} + end + end + + defp release_device(ref, %{devices: devices} = config) do + Process.demonitor(ref, [:flush]) + + case Enum.find(devices, fn {_, device} -> Map.has_key?(device.refs, ref) end) do + {name, device} -> + case Map.delete(device.refs, ref) do + refs when map_size(refs) == 0 -> + revert_device_to_original_pid(name, device.original_pid) + close_string_io(device.pid) + %{config | devices: Map.delete(devices, name)} + + refs -> + put_in(config.devices[name].refs, refs) + end + + _ -> + config + end + end + + defp revert_device_to_original_pid(name, pid) do + Process.unregister(name) + rescue + ArgumentError -> nil + after + Process.register(pid, name) + end + + defp close_string_io(pid) do + StringIO.close(pid) + rescue + ArgumentError -> nil + end + + defp remove_log_capture(ref, %{log_captures: refs} = config) do + case Map.pop(refs, ref, false) do + {true, refs} -> + maybe_add_console(refs, config.log_status) + %{config | log_captures: refs} + + {false, _refs} -> + config + end + end + + defp maybe_add_console(refs, status) do + if status == :ok and map_size(refs) == 0 do + Logger.add_backend(:console, flush: true) + end + end +end diff --git a/engine/lib/engine/build/document.ex b/engine/lib/engine/build/document.ex new file mode 100644 index 00000000..ae9976d7 --- /dev/null +++ b/engine/lib/engine/build/document.ex @@ -0,0 +1,23 @@ +defmodule Engine.Build.Document do + alias Forge.Document + alias Engine.Build + alias Engine.Build.Document.Compilers + alias Engine.Build.Isolation + + @compilers [Compilers.Config, Compilers.Elixir, Compilers.EEx, Compilers.HEEx, Compilers.NoOp] + + def compile(%Document{} = document) do + compiler = Enum.find(@compilers, & &1.recognizes?(document)) + compile_fun = fn -> compiler.compile(document) end + + case Isolation.invoke(compile_fun) do + {:ok, result} -> + result + + {:error, {exception, stack}} -> + diagnostic = Build.Error.error_to_diagnostic(document, exception, stack, nil) + diagnostics = Build.Error.refine_diagnostics([diagnostic]) + {:error, diagnostics} + end + end +end diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex new file mode 100644 index 00000000..4dd0d46e --- /dev/null +++ b/engine/lib/engine/build/document/compiler.ex @@ -0,0 +1,26 @@ +defmodule Engine.Build.Document.Compiler do + @moduledoc """ + A behaviour for document-level compilers + """ + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic + + @type compile_response :: {:ok, [Diagnostic.Result.t()]} | {:error, [Diagnostic.Result.t()]} + + @doc """ + Compiles a document + Compiles a document, returning an error tuple if the document won't compile, + or an ok tuple if it does. In either case, it will also return a list of warnings or errors + """ + @callback compile(Document.t()) :: compile_response() + + @doc """ + Returns true if the document can be compiled by the given compiler. + """ + @callback recognizes?(Document.t()) :: boolean() + + @doc """ + Returns true if the compiler is enabled. + """ + @callback enabled?() :: boolean +end diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex new file mode 100644 index 00000000..bdfb7bfd --- /dev/null +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -0,0 +1,119 @@ +defmodule Engine.Build.Document.Compilers.Config do + @moduledoc """ + A compiler for elixir configuration + """ + alias Elixir.Features + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic + alias Engine.Build + alias Engine.Build.Error.Location + + @elixir_source "Elixir" + + @behaviour Build.Document.Compiler + require Logger + + @impl true + def enabled?, do: true + + @impl true + def recognizes?(%Document{} = document) do + in_config_dir? = + document.path + |> Path.dirname() + |> String.starts_with?(config_dir()) + + in_config_dir? and Path.extname(document.path) == ".exs" + end + + @impl true + def compile(%Document{} = document) do + if Features.with_diagnostics?() do + compile_with_diagnostics(document) + else + raw_compile(document) + end + end + + defp config_dir do + # This function is called inside a call to `in_project` so we can + # call Mix.Project.config() directly + Mix.Project.config() + |> Keyword.get(:config_path) + |> Path.expand() + |> Path.dirname() + end + + defp raw_compile(%Document{} = document) do + contents = Document.to_string(document) + + try do + Config.Reader.eval!(document.path, contents, env: :test) + {:ok, []} + rescue + e -> + {:error, [to_result(document, e, __STACKTRACE__)]} + end + end + + defp compile_with_diagnostics(%Document{} = document) do + {result, diagnostics} = + apply(Code, :with_diagnostics, [ + # credo:disable-for-previous-line + fn -> + raw_compile(document) + end + ]) + + diagnostic_results = Enum.map(diagnostics, &to_result(document, &1)) + + case result do + {:error, errors} -> + {:error, reject_logged_messages(errors ++ diagnostic_results)} + + _ -> + {:ok, reject_logged_messages(diagnostic_results)} + end + end + + defp to_result(document, error, stack \\ []) + + defp to_result(%Document{} = document, %CompileError{} = error, _stack) do + Diagnostic.Result.new( + document.uri, + error.line, + Exception.message(error), + :error, + @elixir_source + ) + end + + defp to_result(%Document{} = document, %error_type{} = error, _stack) + when error_type in [SyntaxError, TokenMissingError] do + Diagnostic.Result.new( + document.uri, + {error.line, error.column}, + Exception.message(error), + :error, + @elixir_source + ) + end + + defp to_result( + %Document{} = document, + %{position: position, message: message, severity: severity}, + _stack + ) do + Diagnostic.Result.new(document.path, position, message, severity, @elixir_source) + end + + defp to_result(%Document{} = document, %{__exception__: true} = exception, stack) do + message = Exception.message(exception) + position = Location.stack_to_position(stack) + Diagnostic.Result.new(document.path, position, message, :error, @elixir_source) + end + + defp reject_logged_messages(results) do + Enum.reject(results, &(&1.message =~ "have been logged")) + end +end diff --git a/engine/lib/engine/build/document/compilers/eex.ex b/engine/lib/engine/build/document/compilers/eex.ex new file mode 100644 index 00000000..c3508344 --- /dev/null +++ b/engine/lib/engine/build/document/compilers/eex.ex @@ -0,0 +1,133 @@ +defmodule Engine.Build.Document.Compilers.EEx do + @moduledoc """ + A compiler for .eex files + """ + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result + alias Engine.Build + alias Engine.Build.Document.Compiler + alias Engine.Build.Document.Compilers + + @behaviour Compiler + + @impl true + def recognizes?(%Document{language_id: "eex"}), do: true + def recognizes?(_), do: false + + @impl true + def enabled?, do: true + + @impl true + def compile(%Document{} = document) do + with {:ok, quoted} <- eex_to_quoted(document), + :ok <- eval_quoted(document, quoted) do + compile_quoted(document, quoted) + end + end + + defp compile_quoted(%Document{} = document, quoted) do + with {:error, errors} <- Compilers.Quoted.compile(document, quoted, "EEx") do + {:error, reject_undefined_assigns(errors)} + end + end + + defp eex_to_quoted(%Document{} = document) do + try do + quoted = + document + |> Document.to_string() + |> EEx.compile_string(file: document.path) + + {:ok, quoted} + rescue + error -> + {:error, [error_to_result(document, error)]} + end + end + + @spec eval_quoted(Document.t(), Macro.t()) :: :ok | {:error, [Result.t()]} + def eval_quoted(%Document{} = document, quoted_ast) do + result = + if Elixir.Features.with_diagnostics?() do + eval_quoted_with_diagnostics(quoted_ast, document.path) + else + do_eval_quoted(quoted_ast, document.path) + end + + case result do + {:ok, _eval_result} -> + :ok + + {{:ok, _eval_result}, _} -> + # Ignore warnings for now + # because they will be handled by `compile_quoted/2` + # like: `assign @thing not available in EEx template` + :ok + + {:exception, exception, stack, _quoted_ast} -> + converted = + document + |> Build.Error.error_to_diagnostic(exception, stack, quoted_ast) + |> Map.put(:source, "EEx") + + {:error, [converted]} + + {{:exception, exception, stack, _quoted_ast}, all_errors_and_warnings} -> + converted = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + maybe_diagnostics = Build.Error.diagnostics_from_mix(document, all_errors_and_warnings) + + diagnostics = + [converted | maybe_diagnostics] + |> Enum.reverse() + |> Build.Error.refine_diagnostics() + |> Enum.map(&Map.replace!(&1, :source, "EEx")) + + {:error, diagnostics} + end + end + + defp eval_quoted_with_diagnostics(quoted_ast, path) do + # Using apply to prevent a compile warning on elixir < 1.15 + # credo:disable-for-next-line + apply(Code, :with_diagnostics, [fn -> do_eval_quoted(quoted_ast, path) end]) + end + + def do_eval_quoted(quoted_ast, path) do + eval_heex_quoted? = + quoted_ast + |> Future.Macro.path(&match?({:require, [context: Phoenix.LiveView.TagEngine], _}, &1)) + |> then(&(not is_nil(&1))) + + env = + if eval_heex_quoted? do + # __ENV__ is required for heex quoted evaluations. + Map.put(__ENV__, :file, path) + else + [file: path] + end + + try do + {result, _} = Code.eval_quoted(quoted_ast, [assigns: %{}], env) + {:ok, result} + rescue + exception -> + {filled_exception, stack} = Exception.blame(:error, exception, __STACKTRACE__) + {:exception, filled_exception, stack, quoted_ast} + end + end + + defp reject_undefined_assigns(errors) do + # NOTE: Ignoring error for assigns makes sense, + # because we don't want such a error report, + # for example: `<%= @name %>` + Enum.reject(errors, fn %Result{message: message} -> + message =~ ~s[undefined variable "assigns"] + end) + end + + defp error_to_result(%Document{} = document, %EEx.SyntaxError{} = error) do + position = {error.line, error.column} + + Result.new(document.uri, position, error.message, :error, "EEx") + end +end diff --git a/engine/lib/engine/build/document/compilers/elixir.ex b/engine/lib/engine/build/document/compilers/elixir.ex new file mode 100644 index 00000000..2e7cbcbd --- /dev/null +++ b/engine/lib/engine/build/document/compilers/elixir.ex @@ -0,0 +1,43 @@ +defmodule Engine.Build.Document.Compilers.Elixir do + @moduledoc """ + A compiler for elixir source files (.ex and .exs) + """ + + alias Elixir.Features + alias Forge.Document + alias Engine.Build + alias Engine.Build.Document.Compilers + + @behaviour Build.Document.Compiler + + @impl true + def recognizes?(%Document{} = doc) do + doc.language_id in ["elixir", "elixir-script"] + end + + @impl true + def enabled?, do: true + + @impl true + def compile(%Document{} = document) do + case to_quoted(document) do + {:ok, quoted} -> + Compilers.Quoted.compile(document, quoted, "Elixir") + + {:error, {meta, message_info, token}} -> + diagnostics = Build.Error.Parse.to_diagnostics(document, meta, message_info, token) + {:error, diagnostics} + end + end + + defp to_quoted(document) do + source_string = Document.to_string(document) + parser_options = [file: document.path] ++ parser_options() + Code.put_compiler_option(:ignore_module_conflict, true) + Code.string_to_quoted(source_string, parser_options) + end + + defp parser_options do + [columns: true, token_metadata: true] + end +end diff --git a/engine/lib/engine/build/document/compilers/heex.ex b/engine/lib/engine/build/document/compilers/heex.ex new file mode 100644 index 00000000..8826417b --- /dev/null +++ b/engine/lib/engine/build/document/compilers/heex.ex @@ -0,0 +1,84 @@ +defmodule Engine.Build.Document.Compilers.HEEx do + @moduledoc """ + A compiler for .heex files + """ + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result + alias Engine.Build.Document.Compiler + alias Engine.Build.Document.Compilers + require Logger + + @behaviour Compiler + + def recognizes?(%Document{language_id: "phoenix-heex"}), do: true + def recognizes?(%Document{language_id: "heex"}), do: true + def recognizes?(_), do: false + + def enabled? do + true + end + + def compile(%Document{} = document) do + with :ok <- eval_heex_quoted(document) do + compile_eex_quoted(document) + end + end + + defp eval_heex_quoted(document) do + with {:ok, quoted} <- heex_to_quoted(document) do + Compilers.EEx.eval_quoted(document, quoted) + end + end + + defp compile_eex_quoted(document) do + with {:error, errors} <- Compilers.EEx.compile(document) do + {:error, reject_undefined_variables(errors)} + end + end + + defp reject_undefined_variables(errors) do + # the undefined variable error is handled by the `eval_heex_quoted` + Enum.reject(errors, fn error -> + error.message =~ "undefined variable" + end) + end + + defp heex_to_quoted(%Document{} = document) do + try do + source = Document.to_string(document) + + opts = + [ + source: source, + file: document.path, + caller: __ENV__, + engine: Phoenix.LiveView.TagEngine, + subengine: Phoenix.LiveView.Engine, + tag_handler: Phoenix.LiveView.HTMLEngine + ] + + quoted = EEx.compile_string(source, opts) + + {:ok, quoted} + rescue + error -> + {:error, [error_to_result(document, error)]} + end + end + + defp error_to_result(%Document{} = document, %EEx.SyntaxError{} = error) do + position = {error.line, error.column} + + Result.new(document.uri, position, error.message, :error, "EEx") + end + + defp error_to_result(document, %error_struct{} = error) + when error_struct in [ + SyntaxError, + TokenMissingError, + Phoenix.LiveView.Tokenizer.ParseError + ] do + position = {error.line, error.column} + Result.new(document.uri, position, error.description, :error, "HEEx") + end +end diff --git a/engine/lib/engine/build/document/compilers/no_op.ex b/engine/lib/engine/build/document/compilers/no_op.ex new file mode 100644 index 00000000..b4f7277a --- /dev/null +++ b/engine/lib/engine/build/document/compilers/no_op.ex @@ -0,0 +1,14 @@ +defmodule Engine.Build.Document.Compilers.NoOp do + @moduledoc """ + A no-op, catch-all compiler. Always enabled, recognizes everything and returns no errors + """ + alias Engine.Build.Document + + @behaviour Document.Compiler + + def recognizes?(_), do: true + + def enabled?, do: true + + def compile(_), do: {:ok, []} +end diff --git a/engine/lib/engine/build/document/compilers/quoted.ex b/engine/lib/engine/build/document/compilers/quoted.ex new file mode 100644 index 00000000..4499523a --- /dev/null +++ b/engine/lib/engine/build/document/compilers/quoted.ex @@ -0,0 +1,282 @@ +defmodule Engine.Build.Document.Compilers.Quoted do + alias Elixir.Features + alias Forge.Ast + alias Forge.Document + alias Engine.Build + alias Engine.ModuleMappings + + import Engine.Build.CaptureIO, only: [capture_io: 2] + + def compile(%Document{} = document, quoted_ast, compiler_name) do + prepare_compile(document.path) + + quoted_ast = + if document.language_id == "elixir-script" do + wrap_top_level_forms(quoted_ast) + else + quoted_ast + end + + {status, diagnostics} = + if Features.with_diagnostics?() do + do_compile(quoted_ast, document) + else + do_compile_and_capture_io(quoted_ast, document) + end + + {status, Enum.map(diagnostics, &replace_source(&1, compiler_name))} + end + + defp do_compile(quoted_ast, document) do + old_modules = ModuleMappings.modules_in_file(document.path) + + case compile_quoted_with_diagnostics(quoted_ast, document.path) do + {{:ok, modules}, []} -> + purge_removed_modules(old_modules, modules) + {:ok, []} + + {{:ok, modules}, all_errors_and_warnings} -> + purge_removed_modules(old_modules, modules) + + diagnostics = + document + |> Build.Error.diagnostics_from_mix(all_errors_and_warnings) + |> Build.Error.refine_diagnostics() + + {:ok, diagnostics} + + {{:exception, exception, stack, quoted_ast}, all_errors_and_warnings} -> + converted = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + maybe_diagnostics = Build.Error.diagnostics_from_mix(document, all_errors_and_warnings) + + diagnostics = + [converted | maybe_diagnostics] + |> Enum.reverse() + |> Build.Error.refine_diagnostics() + + {:error, diagnostics} + end + end + + defp do_compile_and_capture_io(quoted_ast, document) do + # credo:disable-for-next-line Credo.Check.Design.TagTODO + # TODO: remove this function once we drop support for Elixir 1.14 + old_modules = ModuleMappings.modules_in_file(document.path) + compile = fn -> safe_compile_quoted(quoted_ast, document.path) end + + case capture_io(:stderr, compile) do + {captured_messages, {:error, {:exception, {exception, _inner_stack}, stack}}} -> + error = Build.Error.error_to_diagnostic(document, exception, stack, []) + diagnostics = Build.Error.message_to_diagnostic(document, captured_messages) + + {:error, [error | diagnostics]} + + {captured_messages, {:exception, exception, stack, quoted_ast}} -> + error = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + diagnostics = Build.Error.message_to_diagnostic(document, captured_messages) + refined = Build.Error.refine_diagnostics([error | diagnostics]) + + {:error, refined} + + {"", {:ok, modules}} -> + purge_removed_modules(old_modules, modules) + {:ok, []} + + {captured_warnings, {:ok, modules}} -> + purge_removed_modules(old_modules, modules) + + diagnostics = + document + |> Build.Error.message_to_diagnostic(captured_warnings) + |> Build.Error.refine_diagnostics() + + {:ok, diagnostics} + end + end + + defp prepare_compile(path) do + # If we're compiling a mix.exs file, the after compile callback from + # `use Mix.Project` will blow up if we add the same project to the project stack + # twice. Preemptively popping it prevents that error from occurring. + if Path.basename(path) == "mix.exs" do + Mix.ProjectStack.pop() + end + + Mix.Task.run(:loadconfig) + end + + @dialyzer {:nowarn_function, compile_quoted_with_diagnostics: 2} + + defp compile_quoted_with_diagnostics(quoted_ast, path) do + # Using apply to prevent a compile warning on elixir < 1.15 + # credo:disable-for-next-line + apply(Code, :with_diagnostics, [fn -> safe_compile_quoted(quoted_ast, path) end]) + end + + defp safe_compile_quoted(quoted_ast, path) do + try do + {:ok, Code.compile_quoted(quoted_ast, path)} + rescue + exception -> + {filled_exception, stack} = Exception.blame(:error, exception, __STACKTRACE__) + {:exception, filled_exception, stack, quoted_ast} + end + end + + defp purge_removed_modules(old_modules, new_modules) do + new_modules = MapSet.new(new_modules, fn {module, _bytecode} -> module end) + old_modules = MapSet.new(old_modules) + + old_modules + |> MapSet.difference(new_modules) + |> Enum.each(fn to_remove -> + :code.purge(to_remove) + :code.delete(to_remove) + end) + end + + defp replace_source(result, source) do + Map.put(result, :source, source) + end + + @doc false + def wrap_top_level_forms({:__block__, meta, nodes}) do + {chunks, _vars} = + nodes + |> Enum.chunk_by(&should_wrap?/1) + |> Enum.with_index() + |> Enum.flat_map_reduce([], fn {[node | _] = nodes, i}, vars -> + if should_wrap?(node) do + {wrapped, vars} = wrap_nodes(nodes, vars, i) + {[wrapped], vars} + else + {nodes, vars} + end + end) + + {:__block__, meta, chunks} + end + + def wrap_top_level_forms(ast) do + wrap_top_level_forms({:__block__, [], [ast]}) + end + + defp wrap_nodes(nodes, vars, i) do + module_name = :"lexical_wrapper_#{i}" + {nodes, new_vars} = suppress_and_extract_vars(nodes) + + quoted = + quote do + defmodule unquote(module_name) do + def __lexical_wrapper__([unquote_splicing(vars)]) do + (unquote_splicing(nodes)) + end + end + end + + {quoted, new_vars ++ vars} + end + + @allowed_top_level [:defmodule, :alias, :import, :require, :use] + defp should_wrap?({allowed, _, _}) when allowed in @allowed_top_level, do: false + defp should_wrap?(_), do: true + + @doc false + # This function replaces all unused variables with `_` in order + # to suppress warnings while accumulating those vars. The approach + # here is bottom-up, starting from the last expression and working + # back to the beginning: + # + # - If the expression is an assignment, collect vars from the LHS, + # replacing them with `_` if they haven't been referenced, then + # collect references from the RHS. + # - If the expression isn't an assignment, just collect references. + # - Note that pinned vars on the LHS of an assignment are references. + # + def suppress_and_extract_vars(quoted) + + def suppress_and_extract_vars(list) when is_list(list) do + list + |> Enum.reverse() + |> do_suppress_and_extract_vars() + end + + def suppress_and_extract_vars({:__block__, meta, nodes}) do + {nodes, vars} = suppress_and_extract_vars(nodes) + {{:__block__, meta, nodes}, vars} + end + + def suppress_and_extract_vars(expr) do + {[expr], vars} = suppress_and_extract_vars([expr]) + {expr, vars} + end + + defp do_suppress_and_extract_vars(list, acc \\ [], references \\ [], vars \\ []) + + defp do_suppress_and_extract_vars([expr | rest], acc, references, vars) do + {expr, new_vars} = suppress_and_extract_vars_from_expr(expr, references) + new_references = extract_references_from_expr(expr) + + do_suppress_and_extract_vars( + rest, + [expr | acc], + new_references ++ references, + new_vars ++ vars + ) + end + + defp do_suppress_and_extract_vars([], acc, _references, vars) do + {acc, vars} + end + + defp suppress_and_extract_vars_from_expr({:=, meta, [left, right]}, references) do + {left, left_vars} = + Ast.prewalk_vars(left, [], fn + {:^, _, _} = pinned, acc -> + {pinned, acc} + + {name, meta, context} = var, acc -> + if Ast.has_var?(references, name, context) do + {var, [{name, [], context} | acc]} + else + {{:_, meta, nil}, [var | acc]} + end + end) + + {right, right_vars} = suppress_and_extract_vars_from_expr(right, references) + + {{:=, meta, [left, right]}, left_vars ++ right_vars} + end + + defp suppress_and_extract_vars_from_expr(other, _references) do + {other, []} + end + + defp extract_references_from_expr({:=, _, [left, right]}) do + {_, left_references} = + Ast.prewalk_vars(left, [], fn + {:^, _, [referenced_var]}, acc -> + {:ok, [referenced_var | acc]} + + node, acc -> + {node, acc} + end) + + right_references = extract_references_from_expr(right) + + left_references ++ right_references + end + + defp extract_references_from_expr(expr) do + {_, references} = + Ast.prewalk_vars(expr, [], fn + {:^, _, _}, acc -> + {:ok, acc} + + var, acc -> + {:ok, [var | acc]} + end) + + references + end +end diff --git a/engine/lib/engine/build/error.ex b/engine/lib/engine/build/error.ex new file mode 100644 index 00000000..0d4dfd62 --- /dev/null +++ b/engine/lib/engine/build/error.ex @@ -0,0 +1,354 @@ +defmodule Engine.Build.Error do + alias Forge.Ast + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result + alias Engine.Build.Error.Location + alias Mix.Task.Compiler + + require Logger + + @elixir_source "Elixir" + + @doc """ + Diagnostics can come from compiling the whole project, + from compiling individual files, or from erlang's diagnostics (Code.with_diagnostics since elixir1.15), + so we need to do some post-processing. + + Includes: + 1. Normalize each one to the standard result + 2. Format the message to make it readable in the editor + 3. Remove duplicate messages on the same line + """ + def refine_diagnostics(diagnostics) do + diagnostics + |> Enum.map(fn diagnostic -> + diagnostic + |> normalize() + |> format() + end) + |> Location.uniq() + end + + defp normalize(%Compiler.Diagnostic{} = diagnostic) do + Result.new( + diagnostic.file, + diagnostic.position, + diagnostic.message, + diagnostic.severity, + diagnostic.compiler_name + ) + end + + defp normalize(%Result{} = result) do + result + end + + defp format(%Result{} = result) do + %Result{result | message: format_message(result.message)} + end + + @undefined_function_pattern ~r/ \(expected ([A-Za-z0-9_\.]*) to [^\)]+\)/ + + defp format_message("undefined" <> _ = message) do + # All undefined function messages explain the *same* thing inside the parentheses + String.replace(message, @undefined_function_pattern, "") + end + + defp format_message(message) when is_binary(message) do + maybe_format_unused(message) + end + + defp maybe_format_unused(message) do + # Same reason as the `undefined` message above, we can remove the things in parentheses + case String.split(message, "is unused (", parts: 2) do + [prefix, _] -> + prefix <> "is unused" + + _ -> + message + end + end + + @doc """ + The `diagnostics_from_mix/2` is only for Elixir version > 1.15 + + From 1.15 onwards `with_diagnostics` can return some compile-time errors, + more details: https://github.com/elixir-lang/elixir/pull/12742 + """ + def diagnostics_from_mix(%Document{} = doc, all_errors_and_warnings) + when is_list(all_errors_and_warnings) do + for error_or_wanning <- all_errors_and_warnings do + %{position: pos, message: message, severity: severity} = error_or_wanning + + position = + if span = error_or_wanning[:span] do + Location.range(doc, pos, span) + else + pos + end + + Result.new(doc.uri, position, message, severity, @elixir_source) + end + end + + def error_to_diagnostic( + %Document{} = source, + %CompileError{} = compile_error, + _stack, + _quoted_ast + ) do + path = compile_error.file || source.path + + Result.new( + path, + Location.position(compile_error.line), + compile_error.description, + :error, + @elixir_source + ) + end + + def error_to_diagnostic( + %Document{} = source, + %FunctionClauseError{} = function_clause, + stack, + _quoted_ast + ) do + [{_module, _function, _arity, context} | _] = stack + message = Exception.message(function_clause) + position = Location.context_to_position(context) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %Mix.Error{} = error, + _stack, + _quoted_ast + ) do + message = Exception.message(error) + position = Location.position(1) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %UndefinedFunctionError{} = undefined_function, + stack, + quoted_ast + ) do + [{module, function, arguments, context} | _] = stack + message = Exception.message(undefined_function) + + position = + if context == [] and is_list(arguments) do + arity = length(arguments) + mfa = {module, function, arity} + mfa_to_position(mfa, quoted_ast) + else + Location.stack_to_position(stack) + end + + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %RuntimeError{} = runtime_error, + _stack, + _quoted_ast + ) do + message = Exception.message(runtime_error) + position = 1 + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %error_struct{} = argument_error, + stack, + _quoted_ast + ) + when error_struct in [ArgumentError, KeyError] do + reversed_stack = Enum.reverse(stack) + + [{_, _, _, context}, {_, call, _, second_to_last_context} | _] = reversed_stack + + pipe_or_struct? = call in [:|>, :__struct__] + expanding? = second_to_last_context[:file] in [~c"expanding macro", ~c"expanding struct"] + message = Exception.message(argument_error) + + position = + if pipe_or_struct? or expanding? do + Location.context_to_position(context) + else + Location.stack_to_position(stack) + end + + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic(%Document{} = source, %module{} = exception, stack, _quoted_ast) + when module in [ + Protocol.UndefinedError, + ExUnit.DuplicateTestError, + ExUnit.DuplicateDescribeError + ] do + message = Exception.message(exception) + position = Location.stack_to_position(stack) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def message_to_diagnostic(%Document{} = document, message_string) do + message_string + |> extract_individual_messages() + |> Enum.map(&do_message_to_diagnostic(document, &1)) + |> Enum.reject(&is_nil/1) + end + + defp extract_individual_messages(messages) do + messages + |> extract_individual_messages([], []) + end + + defp extract_individual_messages(<<>>, current_message, messages) do + [current_message | messages] + |> Enum.map(&to_message/1) + |> Enum.reverse() + end + + defp extract_individual_messages(<<"error:", rest::binary>>, current_message, messages) do + extract_individual_messages(rest, ["error:"], [current_message | messages]) + end + + defp extract_individual_messages(<<"warning:", rest::binary>>, current_message, messages) do + extract_individual_messages(rest, ["warning:"], [current_message | messages]) + end + + defp extract_individual_messages(<>, current_message, messages) do + extract_individual_messages(rest, [current_message, c], messages) + end + + defp to_message(iodata) do + iodata + |> IO.iodata_to_binary() + |> String.trim() + end + + defp mfa_to_position({module, function, arity}, quoted_ast) do + # Because elixir's Code module has less than stellr line reporting, I think the best we can + # do here is to get the error from the stack trace + + module_path = safe_split(module) + + traverser = fn + {{:., _, [{:__aliases__, _, ^module_path}, ^function]}, context, arguments} = ast, _ + when length(arguments) == arity -> + {ast, context} + + {{:., _, [^module_path, ^function]}, context, arguments} = ast, _ + when length(arguments) == arity -> + {ast, context} + + ast, nil -> + {ast, nil} + + ast, found -> + {ast, found} + end + + {_, context} = Macro.traverse(quoted_ast, nil, traverser, fn ast, acc -> {ast, acc} end) + + cond do + is_nil(context) -> + Location.position(0) + + Keyword.has_key?(context, :line) and Keyword.has_key?(context, :column) -> + Location.position(context[:line], context[:column]) + + Keyword.has_key?(context, :line) -> + Location.position(context[:line]) + + true -> + nil + end + end + + defp safe_split(module) do + case Ast.Module.safe_split(module, as: :atoms) do + {:elixir, segments} -> segments + {:erlang, [erlang_module]} -> erlang_module + end + end + + defp do_message_to_diagnostic(_, "") do + nil + end + + defp do_message_to_diagnostic(_, "warning: redefining module" <> _) do + nil + end + + defp do_message_to_diagnostic(%Document{} = document, message) do + message_lines = String.split(message, "\n") + + with {:ok, location_line} <- find_location(message_lines), + {:ok, {file, line, mfa}} <- parse_location(location_line) do + file = + if blank?(file) do + document.path + else + file + end + + Result.new(file, line, message, :warning, @elixir_source, mfa) + else + _ -> + nil + end + end + + # This regex captures file / line based locations (file.ex:3) + @file_and_line_re ~r/\s+([^:]+):(\d+)/ + # This regex matches the more detailed locations that contain the + # file, line, and the mfa of the error + @location_re ~r/\s+([^:]+):(\d+):\s+([^\.]+)\.(\w+)\/(\d+)?/ + def parse_location(location_string) do + with [] <- Regex.scan(@location_re, location_string), + [[_, file, line]] <- Regex.scan(@file_and_line_re, location_string) do + line = String.to_integer(line) + location = {file, line, nil} + {:ok, location} + else + [[_, file, line, module, function, arity]] -> + line = String.to_integer(line) + module = Module.concat([module]) + function = String.to_atom(function) + arity = String.to_integer(arity) + location = {file, line, {module, function, arity}} + {:ok, location} + + _ -> + :error + end + end + + defp find_location(lines) do + lines + |> Enum.find(fn + line when is_binary(line) -> + Regex.scan(@location_re, line) != [] or Regex.scan(@file_and_line_re, line) != [] + + _ -> + false + end) + |> case do + line when is_binary(line) -> {:ok, line} + nil -> :error + end + end + + defp blank?(s) when is_binary(s) do + String.trim(s) == "" + end +end diff --git a/engine/lib/engine/build/error/location.ex b/engine/lib/engine/build/error/location.ex new file mode 100644 index 00000000..4809e837 --- /dev/null +++ b/engine/lib/engine/build/error/location.ex @@ -0,0 +1,97 @@ +defmodule Engine.Build.Error.Location do + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Plugin.V1.Diagnostic.Result + + require Logger + + def stack_to_position([{_, target, _, _} | rest]) + when target not in [:__FILE__, :__MODULE__] do + stack_to_position(rest) + end + + def stack_to_position([{_, target, _, context} | _rest]) + when target in [:__FILE__, :__MODULE__] do + context_to_position(context) + end + + def stack_to_position([]) do + nil + end + + def context_to_position(context) do + case {context[:line], context[:column]} do + {nil, nil} -> + Logger.error("Invalid context: #{inspect(context)}") + nil + + {line, nil} -> + line + + {line, column} -> + position(line, column) + end + end + + def position(line) do + line + end + + def position(line, column) do + {line, column} + end + + def fetch_range(%Document{} = document, context) do + case {context[:end_line], context[:end_column]} do + {nil, _} -> + :error + + {end_line, end_column} -> + {line, column} = {context[:line], context[:column]} + {:ok, range(document, line, column, end_line, end_column)} + end + end + + def range(%Document{} = document, {line, column}, {end_line, end_column}) do + range(document, line, column, end_line, end_column) + end + + def range(%Document{} = document, line, column, end_line, end_column) do + start_position = Position.new(document, line, column) + end_position = Position.new(document, end_line, end_column) + Range.new(start_position, end_position) + end + + def uniq(diagnostics) do + exacts = Enum.filter(diagnostics, fn diagnostic -> match?(%Range{}, diagnostic.position) end) + + extract_line = fn + %Result{position: {line, _column}} -> line + %Result{position: line} -> line + end + + # Note: Sometimes error and warning appear on one line at the same time + # So we need to uniq by line and severity, + # and :error is always more important than :warning + extract_line_and_severity = &{extract_line.(&1), &1.severity} + + filtered = + diagnostics + |> Enum.filter(fn diagnostic -> not match?(%Range{}, diagnostic.position) end) + |> Enum.sort_by(extract_line_and_severity) + |> Enum.uniq_by(extract_line) + |> reject_zeroth_line() + + exacts ++ filtered + end + + defp reject_zeroth_line(diagnostics) do + # Since 1.15, Elixir has some nonsensical error on line 0, + # e.g.: Can't compile this file + # We can simply ignore it, as there is a more accurate one + Enum.reject(diagnostics, fn diagnostic -> + diagnostic.position == 0 + end) + end +end diff --git a/engine/lib/engine/build/error/parse.ex b/engine/lib/engine/build/error/parse.ex new file mode 100644 index 00000000..f86adbc3 --- /dev/null +++ b/engine/lib/engine/build/error/parse.ex @@ -0,0 +1,198 @@ +defmodule Engine.Build.Error.Parse do + alias Forge.Document + alias Forge.Document.Range + alias Forge.Plugin.V1.Diagnostic.Result + alias Engine.Build.Error.Location + + @elixir_source "Elixir" + + # Parse errors happen during Code.string_to_quoted and are raised as SyntaxErrors, and TokenMissingErrors. + def to_diagnostics( + %Document{} = source, + context, + {_error, detail} = message_info, + token + ) + when is_binary(detail) do + # NOTE: mainly for `unexpected token` errors `< 1.16`, + # its details consist of multiple lines, so it is a tuple. + detail_diagnostics = detail_diagnostics(source, detail) + error = message_info_to_binary(message_info, token) + error_diagnostics = to_diagnostics(source, context, error, token) + Location.uniq(detail_diagnostics ++ error_diagnostics) + end + + def to_diagnostics(%Document{} = source, context, message_info, token) + when is_exception(message_info) do + to_diagnostics(source, context, Exception.message(message_info), token) + end + + def to_diagnostics(%Document{} = source, context, message_info, token) do + {start_line_fn, end_line_fn} = + if Features.details_in_context?() do + {&build_end_line_diagnostics_from_context/4, &build_start_line_diagnostics_from_context/4} + else + {&build_start_line_diagnostics/4, &build_end_line_diagnostics/4} + end + + parse_error_diagnostic_functions = [ + end_line_fn, + start_line_fn, + &build_hint_diagnostics/4 + ] + + parse_error_diagnostic_functions + |> Enum.flat_map(& &1.(source, context, message_info, token)) + |> Location.uniq() + end + + @missing_terminator_pattern ~r/missing terminator: \w+/ + defp build_end_line_diagnostics_from_context( + %Document{} = source, + context, + message_info, + token + ) do + message = + cond do + String.starts_with?(message_info, "unexpected") -> + ~s/#{message_info}#{token}, expected `#{context[:expected_delimiter]}`/ + + Regex.match?(@missing_terminator_pattern, message_info) -> + [message] = Regex.run(@missing_terminator_pattern, message_info) + message + + true -> + "#{message_info}#{token}" + end + + case Location.fetch_range(source, context) do + {:ok, %Range{end: end_pos}} -> + [ + Result.new( + source.uri, + {end_pos.line, end_pos.character}, + message, + :error, + @elixir_source + ) + ] + + :error -> + [] + end + end + + defp build_end_line_diagnostics(%Document{} = source, context, message_info, token) do + [end_line_message | _] = String.split(message_info, "\n") + + message = + if String.ends_with?(end_line_message, token) do + end_line_message + else + end_line_message <> token + end + + diagnostic = + Result.new(source.uri, Location.context_to_position(context), message, :error, "Elixir") + + [diagnostic] + end + + defp build_start_line_diagnostics_from_context( + %Document{} = source, + context, + message_info, + token + ) do + opening_delimiter = context[:opening_delimiter] + + if opening_delimiter do + build_opening_delimiter_diagnostics(source, context, opening_delimiter) + else + build_syntax_error_diagnostic(source, context, message_info, token) + end + end + + defp build_opening_delimiter_diagnostics(%Document{} = source, context, opening_delimiter) do + message = + ~s/The `#{opening_delimiter}` here is missing terminator `#{context[:expected_delimiter]}`/ + + opening_delimiter_length = opening_delimiter |> Atom.to_string() |> String.length() + + pos = + Location.range( + source, + context[:line], + context[:column], + context[:line], + context[:column] + opening_delimiter_length + ) + + result = Result.new(source.uri, pos, message, :error, @elixir_source) + [result] + end + + defp build_syntax_error_diagnostic(%Document{} = source, context, message_info, token) do + message = "#{message_info}#{token}" + pos = Location.position(context[:line], context[:column]) + result = Result.new(source.uri, pos, message, :error, @elixir_source) + [result] + end + + @start_line_regex ~r/(\w+) \(for (.*) starting at line (\d+)\)/ + defp build_start_line_diagnostics(%Document{} = source, _context, message_info, _token) do + case Regex.run(@start_line_regex, message_info) do + [_, missing, token, start_line] -> + message = + ~s[The #{format_token(token)} here is missing terminator #{format_token(missing)}] + + position = String.to_integer(start_line) + result = Result.new(source.uri, position, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + @hint_regex ~r/(HINT:|hint:\e\[0m|hint:)( .*on line (\d+).*)/m + defp build_hint_diagnostics(%Document{} = source, _context, message_info, _token) do + case Regex.run(@hint_regex, message_info) do + [_whole_message, _hint, message, hint_line] -> + message = "HINT:" <> String.replace(message, ~r/on line \d+/, "here") + position = String.to_integer(hint_line) + result = Result.new(source.uri, position, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + defp message_info_to_binary({header, footer}, token) do + header <> token <> footer + end + + @detail_location_re ~r/at line (\d+)/ + defp detail_diagnostics(%Document{} = source, detail) do + case Regex.scan(@detail_location_re, detail) do + [[matched, line_number]] -> + line_number = String.to_integer(line_number) + message = String.replace(detail, matched, "here") + result = Result.new(source.uri, line_number, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + defp format_token(token) when is_binary(token) do + if String.contains?(token, "\"") do + String.replace(token, "\"", "`") + else + "`#{token}`" + end + end +end diff --git a/engine/lib/engine/build/isolation.ex b/engine/lib/engine/build/isolation.ex new file mode 100644 index 00000000..7139fba1 --- /dev/null +++ b/engine/lib/engine/build/isolation.ex @@ -0,0 +1,25 @@ +defmodule Engine.Build.Isolation do + @moduledoc """ + Runs functions in an isolated, monitored process + """ + + @spec invoke((-> term())) :: {:ok, term()} | {:error, term()} + def invoke(function) when is_function(function, 0) do + me = self() + + {pid, ref} = + spawn_monitor(fn -> + send(me, {:result, function.()}) + end) + + receive do + {:result, result} -> + # clean up the DOWN message from the above process in the mailbox. + Process.demonitor(ref, [:flush]) + {:ok, result} + + {:DOWN, ^ref, :process, ^pid, reason} -> + {:error, reason} + end + end +end diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex new file mode 100644 index 00000000..3a9f8ceb --- /dev/null +++ b/engine/lib/engine/build/project.ex @@ -0,0 +1,123 @@ +defmodule Engine.Build.Project do + alias Forge.Project + + alias Engine.Build + alias Engine.Build.Isolation + alias Mix.Task.Compiler.Diagnostic + + use Engine.Progress + require Logger + + def compile(%Project{} = project, initial?) do + Forge.Mix.in_project(fn _ -> + Mix.Task.clear() + + prepare_for_project_build(initial?) + + compile_fun = fn -> + Mix.Task.clear() + + with_progress(building_label(project), fn -> + result = compile_in_isolation() + Mix.Task.run(:loadpaths) + result + end) + end + + case compile_fun.() do + {:error, diagnostics} -> + diagnostics = + diagnostics + |> List.wrap() + |> Build.Error.refine_diagnostics() + + {:error, diagnostics} + + {status, diagnostics} when status in [:ok, :noop] -> + Logger.info( + "Compile completed with status #{status} " <> + "Produced #{length(diagnostics)} diagnostics " <> + inspect(diagnostics) + ) + + Build.Error.refine_diagnostics(diagnostics) + end + end) + end + + defp compile_in_isolation do + compile_fun = fn -> Mix.Task.run(:compile, mix_compile_opts()) end + + case Isolation.invoke(compile_fun) do + {:ok, result} -> + result + + {:error, {exception, [{_mod, _fun, _arity, meta} | _]}} -> + diagnostic = %Diagnostic{ + file: Keyword.get(meta, :file), + severity: :error, + message: Exception.message(exception), + compiler_name: "Elixir", + position: Keyword.get(meta, :line, 1) + } + + {:error, [diagnostic]} + end + end + + defp prepare_for_project_build(false = _initial?) do + :ok + end + + defp prepare_for_project_build(true = _initial?) do + if connected_to_internet?() do + with_progress("mix local.hex", fn -> + Mix.Task.run("local.hex", ~w(--force --if-missing)) + end) + + with_progress("mix local.rebar", fn -> + Mix.Task.run("local.rebar", ~w(--force --if-missing)) + end) + + with_progress("mix deps.get", fn -> + Mix.Task.run("deps.get") + end) + else + Logger.warning("Could not connect to hex.pm, dependencies will not be fetched") + end + + with_progress("mix loadconfig", fn -> + Mix.Task.run(:loadconfig) + end) + + with_progress("mix deps.compile", fn -> + Mix.Task.run("deps.safe_compile", ~w(--skip-umbrella-children)) + end) + end + + defp connected_to_internet? do + # While there's no perfect way to check if a computer is connected to the internet, + # it seems reasonable to gate pulling dependenices on a resolution check for hex.pm. + # Yes, it's entirely possible that the DNS server is local, and that the entry is in cache, + # but that's an edge case, and the build will just time out anyways. + case :inet_res.getbyname(~c"hex.pm", :a, 250) do + {:ok, _} -> true + _ -> false + end + end + + def building_label(%Project{} = project) do + "Building #{Project.display_name(project)}" + end + + defp mix_compile_opts do + ~w( + --return-errors + --ignore-module-conflict + --all-warnings + --docs + --debug-info + --no-protocol-consolidation + ) + end +end diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex new file mode 100644 index 00000000..1a761418 --- /dev/null +++ b/engine/lib/engine/build/state.ex @@ -0,0 +1,258 @@ +defmodule Engine.Build.State do + alias Elixir.Features + alias Forge.Document + alias Forge.Project + + alias Forge.Api.Messages + alias Engine.Build + alias Forge.VM.Versions + + require Logger + + import Messages + + use Engine.Progress + + defstruct project: nil, + build_number: 0, + uri_to_document: %{}, + project_compile: :none + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def on_timeout(%__MODULE__{} = state) do + new_state = + case state.project_compile do + :none -> state + :force -> compile_project(state, true) + :normal -> compile_project(state, false) + end + + # We need to compile the individual documents even after the project is + # compiled because they might have unsaved changes, and we want that state + # to be the latest state of the project. + new_state = + Enum.reduce(new_state.uri_to_document, state, fn {_uri, document}, state -> + compile_file(state, document) + end) + + %__MODULE__{new_state | uri_to_document: %{}, project_compile: :none} + end + + def on_file_compile(%__MODULE__{} = state, %Document{} = document) do + %__MODULE__{ + state + | uri_to_document: Map.put(state.uri_to_document, document.uri, document) + } + end + + def on_project_compile(%__MODULE__{} = state, force?) do + if force? do + %__MODULE__{state | project_compile: :force} + else + %__MODULE__{state | project_compile: :normal} + end + end + + def ensure_build_directory(%__MODULE__{} = state) do + # If the project directory isn't there, for some reason the main build fails, so we create it here + # to ensure that the build will succeed. + project = state.project + build_path = Engine.Build.path(project) + + unless Versions.compatible?(build_path) do + Logger.info("Build path #{build_path} was compiled on a previous erlang version. Deleting") + + if File.exists?(build_path) do + File.rm_rf(build_path) + end + end + + maybe_delete_old_builds(project) + + unless File.exists?(build_path) do + File.mkdir_p!(build_path) + Versions.write(build_path) + end + end + + defp compile_project(%__MODULE__{} = state, initial?) do + state = increment_build_number(state) + project = state.project + + Build.with_lock(fn -> + compile_requested_message = + project_compile_requested(project: project, build_number: state.build_number) + + Engine.broadcast(compile_requested_message) + {elapsed_us, result} = :timer.tc(fn -> Build.Project.compile(project, initial?) end) + elapsed_ms = to_ms(elapsed_us) + + {compile_message, diagnostics} = + case result do + :ok -> + message = project_compiled(status: :success, project: project, elapsed_ms: elapsed_ms) + + {message, []} + + {:ok, diagnostics} -> + message = project_compiled(status: :success, project: project, elapsed_ms: elapsed_ms) + + {message, List.wrap(diagnostics)} + + {:error, diagnostics} -> + message = project_compiled(status: :error, project: project, elapsed_ms: elapsed_ms) + + {message, List.wrap(diagnostics)} + end + + diagnostics_message = + project_diagnostics( + project: project, + build_number: state.build_number, + diagnostics: diagnostics + ) + + Engine.broadcast(compile_message) + Engine.broadcast(diagnostics_message) + end) + + state + end + + def compile_file(%__MODULE__{} = state, %Document{} = document) do + state = increment_build_number(state) + project = state.project + + Build.with_lock(fn -> + Engine.broadcast(file_compile_requested(uri: document.uri)) + + safe_compile_func = fn -> + Forge.Mix.in_project(fn _ -> Build.Document.compile(document) end) + end + + {elapsed_us, result} = :timer.tc(fn -> safe_compile_func.() end) + + elapsed_ms = to_ms(elapsed_us) + + {compile_message, diagnostics} = + case result do + {:ok, diagnostics} -> + message = + file_compiled( + project: project, + build_number: state.build_number, + status: :success, + uri: document.uri, + elapsed_ms: elapsed_ms + ) + + {message, diagnostics} + + {:error, diagnostics} -> + message = + file_compiled( + project: project, + build_number: state.build_number, + status: :error, + uri: document.uri, + elapsed_ms: elapsed_ms + ) + + {message, diagnostics} + end + + diagnostics = + file_diagnostics( + project: project, + build_number: state.build_number, + uri: document.uri, + diagnostics: List.wrap(diagnostics) + ) + + Engine.broadcast(compile_message) + Engine.broadcast(diagnostics) + end) + + state + end + + def set_compiler_options do + Code.compiler_options( + parser_options: parser_options(), + tracers: [Engine.Compilation.Tracer] + ) + + :ok + end + + def mix_compile_opts(initial?) do + opts = ~w( + --return-errors + --ignore-module-conflict + --all-warnings + --docs + --debug-info + --no-protocol-consolidation + ) + + if initial? do + ["--force " | opts] + else + opts + end + end + + def building_label(%Project{} = project) do + "Building #{Project.display_name(project)}" + end + + defp to_ms(microseconds) do + microseconds / 1000 + end + + defp parser_options do + [columns: true, token_metadata: true] + end + + defp increment_build_number(%__MODULE__{} = state) do + %__MODULE__{state | build_number: state.build_number + 1} + end + + @two_month_seconds 86_400 * 31 * 2 + defp maybe_delete_old_builds(%Project{} = project) do + build_root = Project.build_path(project) + two_months_ago = System.system_time(:second) - @two_month_seconds + + case File.ls(build_root) do + {:ok, entries} -> + for file_name <- entries, + absolute_path = Path.join(build_root, file_name), + File.dir?(absolute_path), + newest_beam_mtime(absolute_path) <= + two_months_ago do + File.rm_rf!(absolute_path) + end + + _ -> + :ok + end + end + + defp newest_beam_mtime(directory) do + directory + |> Path.join("**/*.beam") + |> Path.wildcard() + |> then(fn + [] -> + 0 + + beam_files -> + beam_files + |> Enum.map(&File.stat!(&1, time: :posix).mtime) + |> Enum.max() + end) + end +end diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex new file mode 100644 index 00000000..b42cb659 --- /dev/null +++ b/engine/lib/engine/commands/reindex.ex @@ -0,0 +1,165 @@ +defmodule Engine.Commands.Reindex do + defmodule State do + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.ProcessCache + alias Forge.Search + alias Forge.Search.Indexer + + require Logger + require ProcessCache + + defstruct reindex_fun: nil, index_task: nil, pending_updates: %{} + + def new(reindex_fun) do + %__MODULE__{reindex_fun: reindex_fun} + end + + def set_task(%__MODULE__{} = state, {_, _} = task) do + %__MODULE__{state | index_task: task} + end + + def clear_task(%__MODULE__{} = state) do + %__MODULE__{state | index_task: nil} + end + + def reindex_uri(%__MODULE__{index_task: nil} = state, uri) do + case entries_for_uri(uri) do + {:ok, path, entries} -> + Search.Store.update(path, entries) + + _ -> + :ok + end + + state + end + + def reindex_uri(%__MODULE__{} = state, uri) do + case entries_for_uri(uri) do + {:ok, path, entries} -> + put_in(state.pending_updates[path], entries) + + _ -> + state + end + end + + def flush_pending_updates(%__MODULE__{} = state) do + Enum.each(state.pending_updates, fn {path, entries} -> + Search.Store.update(path, entries) + end) + + %__MODULE__{state | pending_updates: %{}} + end + + defp entries_for_uri(uri) do + with {:ok, %Document{} = document, %Analysis{} = analysis} <- + Document.Store.fetch(uri, :analysis), + {:ok, entries} <- Indexer.Quoted.index_with_cleanup(analysis) do + {:ok, document.path, entries} + else + error -> + Logger.error("Could not update index because #{inspect(error)}") + error + end + end + end + + @moduledoc """ + A simple genserver that prevents more than one reindexing job from running at the same time + """ + + alias Forge.Document + alias Forge.Project + + alias Forge.Search + + use GenServer + import Forge.Api.Messages + + def start_link(opts) do + [reindex_fun: fun] = Keyword.validate!(opts, reindex_fun: &do_reindex/1) + GenServer.start_link(__MODULE__, fun, name: __MODULE__) + end + + def uri(uri) do + GenServer.cast(__MODULE__, {:reindex_uri, uri}) + end + + def perform do + perform(Forge.get_project()) + end + + def perform(%Project{} = project) do + GenServer.call(__MODULE__, {:perform, project}) + end + + def running? do + GenServer.call(__MODULE__, :running?) + end + + @impl GenServer + def init(reindex_fun) do + Process.flag(:fullsweep_after, 5) + schedule_gc() + {:ok, State.new(reindex_fun)} + end + + @impl GenServer + def handle_call(:running?, _from, %State{index_task: index_task} = state) do + {:reply, match?({_, _}, index_task), state} + end + + def handle_call({:perform, project}, _from, %State{index_task: nil} = state) do + index_task = spawn_monitor(fn -> state.reindex_fun.(project) end) + {:reply, :ok, State.set_task(state, index_task)} + end + + def handle_call({:perform, _project}, _from, state) do + {:reply, {:error, "Already Running"}, state} + end + + @impl GenServer + def handle_cast({:reindex_uri, uri}, %State{} = state) do + {:noreply, State.reindex_uri(state, uri)} + end + + @impl GenServer + def handle_info({:DOWN, ref, :process, pid, _reason}, %State{index_task: {pid, ref}} = state) do + new_state = + state + |> State.flush_pending_updates() + |> State.clear_task() + + {:noreply, new_state} + end + + @impl GenServer + def handle_info(:gc, %State{} = state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + defp do_reindex(%Project{} = project) do + Engine.broadcast(project_reindex_requested(project: project)) + + {elapsed_us, result} = + :timer.tc(fn -> + with {:ok, entries} <- Search.Indexer.create_index(project) do + Search.Store.replace(entries) + end + end) + + Engine.broadcast( + project_reindexed(project: project, elapsed_ms: round(elapsed_us / 1000), status: :success) + ) + + result + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end +end diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex new file mode 100644 index 00000000..cfc64c9c --- /dev/null +++ b/engine/lib/engine/compilation/tracer.ex @@ -0,0 +1,80 @@ +defmodule Engine.Compilation.Tracer do + alias Engine.Build + alias Forge.Module.Loader + + import Forge.Api.Messages + + def trace({:on_module, module_binary, _filename}, %Macro.Env{} = env) do + message = extract_module_updated(env.module, module_binary, env.file) + maybe_report_progress(env.file) + Engine.broadcast(message) + :ok + end + + def trace(_event, _env) do + :ok + end + + def extract_module_updated(module, module_binary, filename) do + unless Loader.ensure_loaded?(module) do + erlang_filename = + filename + |> ensure_filename() + |> String.to_charlist() + + :code.load_binary(module, erlang_filename, module_binary) + end + + functions = module.__info__(:functions) + macros = module.__info__(:macros) + + struct = + if function_exported?(module, :__struct__, 0) do + module.__struct__() + |> Map.from_struct() + |> Enum.map(fn {k, v} -> + %{field: k, required?: !is_nil(v)} + end) + end + + module_updated( + file: filename, + functions: functions, + macros: macros, + name: module, + struct: struct + ) + end + + defp ensure_filename(:none) do + unique = System.unique_integer([:positive, :monotonic]) + Path.join(System.tmp_dir(), "file-#{unique}.ex") + end + + defp ensure_filename(filename) when is_binary(filename) do + filename + end + + defp maybe_report_progress(file) do + if Path.extname(file) == ".ex" do + file + |> progress_message() + |> Engine.broadcast() + end + end + + defp progress_message(file) do + relative_path_elements = + file + |> Path.relative_to_cwd() + |> Path.split() + + base_dir = List.first(relative_path_elements) + file_name = List.last(relative_path_elements) + + message = "compiling: " <> Path.join([base_dir, "...", file_name]) + + label = Build.State.building_label(Forge.get_project()) + project_progress(label: label, message: message) + end +end diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex new file mode 100644 index 00000000..818a33aa --- /dev/null +++ b/engine/lib/engine/completion.ex @@ -0,0 +1,139 @@ +defmodule Engine.Completion do + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Position + + alias Forge.CodeMod.Format + alias Forge.Completion.Candidate + + import Document.Line + + def elixir_sense_expand(%Env{} = env) do + {doc_string, position} = strip_struct_operator(env) + + line = position.line + character = position.character + hint = ElixirSense.Core.Source.prefix(doc_string, line, character) + + if String.trim(hint) == "" do + [] + else + {_formatter, opts} = Format.formatter_for_file(env.project, env.document.path) + locals_without_parens = Keyword.fetch!(opts, :locals_without_parens) + + for suggestion <- ElixirSense.suggestions(doc_string, line, character), + candidate = from_elixir_sense(suggestion, locals_without_parens), + candidate != nil do + candidate + end + end + end + + defp from_elixir_sense(suggestion, locals_without_parens) do + suggestion + |> Candidate.from_elixir_sense() + |> maybe_suppress_parens(locals_without_parens) + end + + defp maybe_suppress_parens(%struct{} = candidate, locals_without_parens) + when struct in [Candidate.Function, Candidate.Macro, Candidate.Typespec] do + atom_name = String.to_atom(candidate.name) + suppress_parens? = local_without_parens?(atom_name, candidate.arity, locals_without_parens) + + %{candidate | parens?: not suppress_parens?} + end + + defp maybe_suppress_parens(candidate, _), do: candidate + + defp local_without_parens?(fun, arity, locals_without_parens) do + arity > 0 and + Enum.any?(locals_without_parens, fn + {^fun, :*} -> true + {^fun, ^arity} -> true + _ -> false + end) + end + + def struct_fields(%Analysis{} = analysis, %Position{} = position) do + container_struct_module = + analysis + |> Forge.Ast.cursor_path(position) + |> container_struct_module() + + with {:ok, struct_module} <- + Forge.Analyzer.expand_alias(container_struct_module, analysis, position), + true <- function_exported?(struct_module, :__struct__, 0) do + struct_module + |> struct() + |> Map.from_struct() + |> Map.keys() + |> Enum.map(&Candidate.StructField.new(&1, struct_module)) + else + _ -> [] + end + end + + defp container_struct_module(cursor_path) do + Enum.find_value(cursor_path, fn + # current module struct: `%__MODULE__{|}` + {:%, _, [{:__MODULE__, _, _} | _]} -> [:__MODULE__] + # struct leading by current module: `%__MODULE__.Struct{|}` + {:%, _, [{:__aliases__, _, [{:__MODULE__, _, _} | tail]} | _]} -> [:__MODULE__ | tail] + # Struct leading by alias or just a aliased Struct: `%Struct{|}`, `%Project.Struct{|}` + {:%, _, [{:__aliases__, _, aliases} | _]} -> aliases + _ -> nil + end) + end + + # HACK: This fixes ElixirSense struct completions for certain cases. + # We should try removing when we update or remove ElixirSense. + defp strip_struct_operator(%Env{} = env) do + with true <- Env.in_context?(env, :struct_reference), + {:ok, completion_length} <- fetch_struct_completion_length(env) do + column = env.position.character + percent_position = column - (completion_length + 1) + + new_line_start = String.slice(env.line, 0, percent_position - 1) + new_line_end = String.slice(env.line, percent_position..-1//1) + new_line = [new_line_start, new_line_end] + new_position = Position.new(env.document, env.position.line, env.position.character - 1) + line_to_replace = env.position.line + + stripped_text = + env.document.lines + |> Enum.with_index(1) + |> Enum.reduce([], fn + {line(ending: ending), ^line_to_replace}, acc -> + [acc, new_line, ending] + + {line(text: line_text, ending: ending), _}, acc -> + [acc, line_text, ending] + end) + |> IO.iodata_to_binary() + + {stripped_text, new_position} + else + _ -> + doc_string = Document.to_string(env.document) + {doc_string, env.position} + end + end + + defp fetch_struct_completion_length(env) do + case Code.Fragment.cursor_context(env.prefix) do + {:struct, {:dot, {:alias, struct_name}, []}} -> + # add one because of the trailing period + {:ok, length(struct_name) + 1} + + {:struct, {:local_or_var, local_name}} -> + {:ok, length(local_name)} + + {:struct, struct_name} -> + {:ok, length(struct_name)} + + {:local_or_var, local_name} -> + {:ok, length(local_name)} + end + end +end diff --git a/engine/lib/engine/document_symbols.ex b/engine/lib/engine/document_symbols.ex deleted file mode 100644 index 47305fad..00000000 --- a/engine/lib/engine/document_symbols.ex +++ /dev/null @@ -1,237 +0,0 @@ -defmodule Engine.DocumentSymbol do - @moduledoc false - - alias GenLSP.Enumerations.SymbolKind - alias GenLSP.Structures.DocumentSymbol - alias GenLSP.Structures.Position - alias GenLSP.Structures.Range - - @spec fetch(text :: String.t()) :: list(DocumentSymbol.t()) - def fetch(text) do - ast = - case Spitfire.parse( - text, - # we set the literal encoder so that we can know when atoms and strings start and end - # this makes it useful for knowing the exact locations of struct field definitions - literal_encoder: fn literal, meta -> - if is_atom(literal) or is_binary(literal) do - {:ok, {:__literal__, meta, [literal]}} - else - {:ok, literal} - end - end, - unescape: false, - token_metadata: true, - columns: true - ) do - {:error, ast, _errors} -> - ast - - {:error, _} -> - raise "Failed to parse!" - - {:ok, ast} -> - ast - end - - List.wrap(walker(ast, nil)) - end - - defp walker([{{:__literal__, _, [:do]}, {_, _, _exprs} = ast}], mod) do - walker(ast, mod) - end - - defp walker({:__block__, _, exprs}, mod) do - for expr <- exprs, sym = walker(expr, mod), sym != nil do - sym - end - end - - defp walker({:defmodule, meta, [name | children]}, _mod) do - name = Macro.to_string(unliteral(name)) - - %DocumentSymbol{ - name: name, - kind: SymbolKind.module(), - children: - List.flatten(for(child <- children, sym = walker(child, name), sym != nil, do: sym)), - range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:end][:line] - 1, character: meta[:end][:column] - 1} - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:describe, meta, [name | children]}, mod) do - name = String.replace("describe " <> Macro.to_string(unliteral(name)), "\n", "") - - %DocumentSymbol{ - name: name, - kind: SymbolKind.class(), - children: - List.flatten(for(child <- children, sym = walker(child, mod), sym != nil, do: sym)), - range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:end][:line] - 1, character: meta[:end][:column] - 1} - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:defstruct, meta, [fields]}, mod) do - fields = - for field <- fields do - {name, start_line, start_column} = - case field do - {:__literal__, meta, [name]} -> - start_line = meta[:line] - 1 - start_column = meta[:column] - 1 - name = Macro.to_string(name) - - {name, start_line, start_column} - - {{:__literal__, meta, [name]}, default} -> - start_line = meta[:line] - 1 - start_column = meta[:column] - 1 - name = to_string(name) <> ": " <> Macro.to_string(unliteral(default)) - - {name, start_line, start_column} - end - - %DocumentSymbol{ - name: name, - children: [], - kind: SymbolKind.field(), - range: %Range{ - start: %Position{ - line: start_line, - character: start_column - }, - end: %Position{ - line: start_line, - character: start_column + String.length(name) - } - }, - selection_range: %Range{ - start: %Position{line: start_line, character: start_column}, - end: %Position{line: start_line, character: start_column} - } - } - end - - %DocumentSymbol{ - name: "%#{mod}{}", - children: fields, - kind: elixir_kind_to_lsp_kind(:defstruct), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end_of_expression][:line] || meta[:line]) - 1, - character: (meta[:end_of_expression][:column] || meta[:column]) - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:@, meta, [{_name, _, value}]} = attribute, _) when length(value) > 0 do - %DocumentSymbol{ - name: attribute |> unliteral() |> Macro.to_string() |> String.replace("\n", ""), - children: [], - kind: elixir_kind_to_lsp_kind(:@), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({type, meta, [name | _children]}, _) when type in [:test, :feature, :property] do - %DocumentSymbol{ - name: String.replace("#{type} #{Macro.to_string(unliteral(name))}", "\n", ""), - children: [], - kind: SymbolKind.constructor(), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end] || meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end] || meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({type, meta, [name | _children]}, _) - when type in [:def, :defp, :defmacro, :defmacro] do - %DocumentSymbol{ - name: String.replace("#{type} #{name |> unliteral() |> Macro.to_string()}", "\n", ""), - children: [], - kind: elixir_kind_to_lsp_kind(type), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end] || meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end] || meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker(_ast, _) do - nil - end - - defp unliteral(ast) do - Macro.prewalk(ast, fn - {:__literal__, _, [literal]} -> - literal - - node -> - node - end) - end - - defp elixir_kind_to_lsp_kind(:defstruct), do: SymbolKind.struct() - defp elixir_kind_to_lsp_kind(:@), do: SymbolKind.property() - - defp elixir_kind_to_lsp_kind(kind) - when kind in [:def, :defp, :defmacro, :defmacrop, :test, :describe], - do: SymbolKind.function() -end diff --git a/engine/lib/engine/mix.tasks.deps.safe_compile.ex b/engine/lib/engine/mix.tasks.deps.safe_compile.ex new file mode 100644 index 00000000..51d871cc --- /dev/null +++ b/engine/lib/engine/mix.tasks.deps.safe_compile.ex @@ -0,0 +1,381 @@ +defmodule Mix.Tasks.Deps.SafeCompile do + use Mix.Task + + @shortdoc "Compiles dependencies" + + @moduledoc """ + Compiles dependencies. + + By default, this task attempts to compile all dependencies. + A list of dependencies can be given to compile multiple + dependencies in order. + + This task attempts to detect if the project contains one of + the following files and act accordingly: + + * `mix.exs` - invokes `mix compile` + * `rebar.config` - invokes `rebar compile` + * `Makefile.win`- invokes `nmake /F Makefile.win` (only on Windows) + * `Makefile` - invokes `gmake` on DragonFlyBSD, FreeBSD, NetBSD, and OpenBSD, + invokes `make` on any other operating system (except on Windows) + + The compilation can be customized by passing a `compile` option + in the dependency: + + {:some_dependency, "0.1.0", compile: "command to compile"} + + If a list of dependencies is given, Mix will attempt to compile + them as is. For example, if project `a` depends on `b`, calling + `mix deps.compile a` will compile `a` even if `b` is out of + date. This is to allow parts of the dependency tree to be + recompiled without propagating those changes upstream. To ensure + `b` is included in the compilation step, pass `--include-children`. + + ## Command line options + + * `--force` - force compilation of deps + * `--skip-umbrella-children` - skips umbrella applications from compiling + * `--skip-local-deps` - skips non-remote dependencies, such as path deps, from compiling + + """ + + @switches [ + include_children: :boolean, + force: :boolean, + skip_umbrella_children: :boolean, + skip_local_deps: :boolean + ] + + @impl true + def run(args) do + if Elixir.Features.compile_keeps_current_directory?() do + Mix.Tasks.Deps.Compile.run(args) + else + unless "--no-archives-check" in args do + Mix.Task.run("archive.check", args) + end + + Mix.Project.get!() + deps = Mix.Dep.load_and_cache() + + case OptionParser.parse(args, switches: @switches) do + {opts, [], _} -> + # Because this command may be invoked explicitly with + # deps.compile, we simply try to compile any available + # or local dependency. + compile(filter_available_and_local_deps(deps), opts) + + {opts, tail, _} -> + compile(Mix.Dep.filter_by_name(tail, deps, opts), opts) + end + end + end + + @doc false + def compile(deps, options \\ []) do + shell = Mix.shell() + config = Mix.Project.deps_config() + Mix.Task.run("deps.precompile") + + compiled = + deps + |> reject_umbrella_children(options) + |> reject_local_deps(options) + |> Enum.map(fn %Mix.Dep{app: app, status: status, opts: opts, scm: scm} = dep -> + check_unavailable!(app, scm, status) + maybe_clean(dep, options) + + compiled? = + cond do + not is_nil(opts[:compile]) -> + do_compile(dep, config) + + Mix.Dep.mix?(dep) -> + do_mix(dep, config) + + Mix.Dep.make?(dep) -> + do_make(dep, config) + + dep.manager == :rebar3 -> + do_rebar3(dep, config) + + true -> + shell.error( + ~s[Could not compile #{inspect(app)}, no "mix.exs", "rebar.config" or "Makefile"] <> + ~s[pass :compile as an option to customize compilation, set it to "false" to do nothing] + ) + + false + end + + # We should touch fetchable dependencies even if they + # did not compile otherwise they will always be marked + # as stale, even when there is nothing to do. + fetchable? = touch_fetchable(scm, opts[:build]) + + compiled? and fetchable? + end) + + if true in compiled, do: Mix.Task.run("will_recompile"), else: :ok + end + + defp maybe_clean(dep, opts) do + # If a dependency was marked as fetched or with an out of date lock + # or missing the app file, we always compile it from scratch. + if Keyword.get(opts, :force, false) or Mix.Dep.compilable?(dep) do + File.rm_rf!(Path.join([Mix.Project.build_path(), "lib", Atom.to_string(dep.app)])) + end + end + + defp touch_fetchable(scm, path) do + if scm.fetchable? do + path = Path.join(path, ".mix") + File.mkdir_p!(path) + File.touch!(Path.join(path, "compile.fetch")) + true + else + false + end + end + + defp check_unavailable!(app, scm, {:unavailable, path}) do + if scm.fetchable? do + Mix.raise( + "Cannot compile dependency #{inspect(app)} because " <> + "it isn't available, run \"mix deps.get\" first" + ) + else + Mix.raise( + "Cannot compile dependency #{inspect(app)} because " <> + "it isn't available, please ensure the dependency is at " <> + inspect(Path.relative_to_cwd(path)) + ) + end + end + + defp check_unavailable!(_, _, _) do + :ok + end + + defp do_mix(dep, _config) do + Mix.Dep.in_dependency(dep, fn _ -> + config = Mix.Project.config() + + if req = old_elixir_req(config) do + Mix.shell().error( + "warning: the dependency #{inspect(dep.app)} requires Elixir #{inspect(req)} " <> + "but you are running on v#{System.version()}" + ) + end + + try do + options = [ + "--from-mix-deps-compile", + "--no-archives-check", + "--no-warnings-as-errors" + ] + + res = Mix.Task.run("compile", options) + match?({:ok, _}, res) + catch + kind, reason -> + app = dep.app + + Mix.shell().error( + "could not compile dependency #{inspect(app)}, \"mix compile\" failed. " <> + deps_compile_feedback(app) + ) + + :erlang.raise(kind, reason, __STACKTRACE__) + end + end) + end + + defp do_rebar3(%Mix.Dep{opts: opts} = dep, config) do + dep_path = opts[:dest] + build_path = opts[:build] + + # For Rebar3, we need to copy the source/ebin to the target/ebin + # before we run the command given that REBAR_BARE_COMPILER_OUTPUT_DIR + # writes directly to _build. + # + # credo:disable-for-next-line Credo.Check.Design.TagTODO + # TODO: We still symlink ebin/ by default for backwards compatibility. + # This partially negates the effects of REBAR_BARE_COMPILER_OUTPUT_DIR + # if an ebin directory exists, so we should consider disabling it in future + # releases when rebar3 v3.14+ is reasonably adopted. + config = Keyword.put(config, :app_path, build_path) + Mix.Project.build_structure(config, symlink_ebin: true, source: dep_path) + + # Build the rebar config and setup the command line + config_path = Path.join(build_path, "mix.rebar.config") + lib_path = Path.join(config[:env_path], "lib/*/ebin") + File.write!(config_path, rebar_config(dep)) + + env = [ + # REBAR_BARE_COMPILER_OUTPUT_DIR is only honored by rebar3 >= 3.14 + {"REBAR_BARE_COMPILER_OUTPUT_DIR", build_path}, + {"REBAR_CONFIG", config_path}, + {"REBAR_PROFILE", "prod"}, + {"TERM", "dumb"} + ] + + cmd = "#{rebar_cmd(dep)} bare compile --paths #{lib_path}" + do_command(dep, config, cmd, false, env) + + build_priv = Path.join(build_path, "priv") + dep_priv = Path.join(dep_path, "priv") + + # Copy priv/ after compilation too if it was created then + if File.exists?(dep_priv) and not File.exists?(build_priv) do + Mix.Utils.symlink_or_copy(dep_priv, build_priv) + end + + Code.prepend_path(Path.join(build_path, "ebin")) + true + end + + defp rebar_config(dep) do + dep.extra + |> Mix.Rebar.dependency_config() + |> Mix.Rebar.serialize_config() + end + + defp rebar_cmd(%Mix.Dep{manager: manager} = dep) do + Mix.Rebar.rebar_cmd(manager) || handle_rebar_not_found(dep) + end + + defp handle_rebar_not_found(%Mix.Dep{app: app, manager: manager}) do + shell = Mix.shell() + + shell.info( + "Could not find \"#{manager}\", which is needed to build dependency #{inspect(app)}" + ) + + shell.info("I can install a local copy which is just used by Mix") + + install_question = + "Shall I install #{manager}? (if running non-interactively, " <> + "use \"mix local.rebar --force\")" + + unless shell.yes?(install_question) do + error_message = + "Could not find \"#{manager}\" to compile " <> + "dependency #{inspect(app)}, please ensure \"#{manager}\" is available" + + Mix.raise(error_message) + end + + (Mix.Tasks.Local.Rebar.run([]) && Mix.Rebar.local_rebar_cmd(manager)) || + Mix.raise("\"#{manager}\" installation failed") + end + + defp do_make(dep, config) do + command = make_command(dep) + do_command(dep, config, command, true, [{"IS_DEP", "1"}]) + build_structure(dep, config) + true + end + + defp make_command(dep) do + makefile_win? = makefile_win?(dep) + + command = + case :os.type() do + {:win32, _} when makefile_win? -> + "nmake /F Makefile.win" + + {:unix, type} when type in [:dragonfly, :freebsd, :netbsd, :openbsd] -> + "gmake" + + _ -> + "make" + end + + if erlang_mk?(dep) do + "#{command} clean && #{command}" + else + command + end + end + + defp do_compile(%Mix.Dep{opts: opts} = dep, config) do + if command = opts[:compile] do + do_command(dep, config, command, true) + build_structure(dep, config) + true + else + false + end + end + + defp do_command(dep, config, command, print_app?, env \\ []) do + %Mix.Dep{app: app, system_env: system_env, opts: opts} = dep + + env = [{"ERL_LIBS", Path.join(config[:env_path], "lib")} | system_env] ++ env + + if Mix.shell().cmd(command, env: env, print_app: print_app?, cd: opts[:dest]) != 0 do + Mix.raise( + "Could not compile dependency #{inspect(app)}, \"#{command}\" command failed. " <> + deps_compile_feedback(app) + ) + end + + true + end + + defp build_structure(%Mix.Dep{opts: opts}, config) do + config = Keyword.put(config, :app_path, opts[:build]) + Mix.Project.build_structure(config, symlink_ebin: true, source: opts[:dest]) + Code.prepend_path(Path.join(opts[:build], "ebin")) + end + + defp old_elixir_req(config) do + req = config[:elixir] + + if req && not Version.match?(System.version(), req) do + req + end + end + + defp erlang_mk?(%Mix.Dep{opts: opts}) do + File.regular?(Path.join(opts[:dest], "erlang.mk")) + end + + defp makefile_win?(%Mix.Dep{opts: opts}) do + File.regular?(Path.join(opts[:dest], "Makefile.win")) + end + + defp reject_umbrella_children(deps, options) do + if options[:skip_umbrella_children] do + Enum.reject(deps, fn %{opts: opts} -> Keyword.get(opts, :from_umbrella) == true end) + else + deps + end + end + + defp filter_available_and_local_deps(deps) do + Enum.filter(deps, fn dep -> + Mix.Dep.available?(dep) or not dep.scm.fetchable? + end) + end + + defp reject_local_deps(deps, options) do + if options[:skip_local_deps] do + Enum.filter(deps, fn %{scm: scm} -> scm.fetchable? end) + else + deps + end + end + + defp deps_compile_feedback(app) do + if Mix.install?() do + "Errors may have been logged above. You may run Mix.install/2 to try again or " <> + "change the arguments to Mix.install/2 to try another version" + else + "Errors may have been logged above. You can recompile this dependency with " <> + ~s["mix deps.compile #{app}", update it with "mix deps.update #{app}" or ] <> + ~s[clean it with "mix deps.clean #{app}"] + end + end +end diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex new file mode 100644 index 00000000..05f34c32 --- /dev/null +++ b/engine/lib/engine/module_mappings.ex @@ -0,0 +1,84 @@ +defmodule Engine.ModuleMappings do + defmodule State do + defstruct module_to_file: %{}, file_to_modules: %{} + + def new do + %__MODULE__{} + end + + def file_for_module(%__MODULE__{} = state, module) do + Map.get(state.module_to_file, module) + end + + def modules_in_file(%__MODULE__{} = state, file_path) do + Map.get(state.file_to_modules, file_path, []) + end + + def update(%__MODULE__{} = state, module, file_path) do + file_to_modules = + case state.module_to_file do + %{^module => ^file_path} -> + # the module has already been associated with this path + state.file_to_modules + + %{^module => old_path} -> + # the module has changed its file + remove_this_module? = fn old_module -> old_module == module end + + state.file_to_modules + |> Map.update(old_path, [], &Enum.reject(&1, remove_this_module?)) + |> Map.update(file_path, [module], &[module | &1]) + + _ -> + # it didn't exist previously + Map.update(state.file_to_modules, file_path, [module], &[module | &1]) + end + + module_to_file = Map.put(state.module_to_file, module, file_path) + %__MODULE__{state | file_to_modules: file_to_modules, module_to_file: module_to_file} + end + end + + alias Forge.Api.Messages + + use GenServer + + import Messages + + # Public + def start_link(_) do + GenServer.start_link(__MODULE__, :ok, name: __MODULE__) + end + + def file_for_module(module) do + GenServer.call(__MODULE__, {:file_for_module, module}) + end + + def modules_in_file(file_path) do + GenServer.call(__MODULE__, {:modules_in_file, file_path}) + end + + # GenServer callbacks + + @impl GenServer + def init(_) do + Engine.register_listener(self(), [module_updated()]) + {:ok, State.new()} + end + + @impl GenServer + def handle_call({:modules_in_file, file_path}, _from, %State{} = state) do + {:reply, State.modules_in_file(state, file_path), state} + end + + @impl GenServer + def handle_call({:file_for_module, module}, _from, %State{} = state) do + {:reply, State.file_for_module(state, module), state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name, file: file_path), %State{} = state) do + new_state = State.update(state, module_name, file_path) + {:noreply, new_state} + end +end diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex new file mode 100644 index 00000000..0e9d510b --- /dev/null +++ b/engine/lib/engine/port.ex @@ -0,0 +1,86 @@ +defmodule Engine.Port do + @moduledoc """ + Utilities for launching ports in the context of a project + """ + + alias Forge.Project + + @type open_opt :: + {:env, list()} + | {:cd, String.t() | charlist()} + | {:env, [{:os.env_var_name(), :os.env_var_value()}]} + | {:args, list()} + + @type open_opts :: [open_opt] + + @doc """ + Launches elixir in a port. + + This function takes the project's context into account and looks for the executable via calling + `Engine.elixir_executable(project)`. Environment variables are also retrieved with that call. + """ + @spec open_elixir(Project.t(), open_opts()) :: port() + def open_elixir(%Project{} = project, opts) do + {:ok, elixir_executable, environment_variables} = Engine.elixir_executable(project) + + opts = + opts + |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end) + |> Keyword.put_new(:env, environment_variables) + + open(project, elixir_executable, opts) + end + + @doc """ + Launches an executable in the project context via a port. + """ + def open(%Project{} = project, executable, opts) do + {launcher, opts} = Keyword.pop_lazy(opts, :path, &path/0) + + opts = + opts + |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end) + |> Keyword.update(:args, [executable], fn old_args -> + [executable | Enum.map(old_args, &to_string/1)] + end) + + opts = + if Keyword.has_key?(opts, :env) do + Keyword.update!(opts, :env, &ensure_charlists/1) + else + opts + end + + Port.open({:spawn_executable, launcher}, opts) + end + + @doc """ + Provides the path of an executable to launch another erlang node via ports. + """ + def path do + path(:os.type()) + end + + def path({:unix, _}) do + with :non_existing <- :code.where_is_file(~c"port_wrapper.sh") do + :remote_control + |> :code.priv_dir() + |> Path.join("port_wrapper.sh") + |> Path.expand() + end + |> to_string() + end + + def path(os_tuple) do + raise ArgumentError, "Operating system #{inspect(os_tuple)} is not currently supported" + end + + defp ensure_charlists(environment_variables) do + Enum.map(environment_variables, fn {key, value} -> + # using to_string ensures nil values won't blow things up + erl_key = key |> to_string() |> String.to_charlist() + erl_value = value |> to_string() |> String.to_charlist() + {erl_key, erl_value} + end) + end +end diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex new file mode 100644 index 00000000..1f977e35 --- /dev/null +++ b/engine/lib/engine/progress.ex @@ -0,0 +1,66 @@ +defmodule Engine.Progress do + import Forge.Api.Messages + + @type label :: String.t() + @type message :: String.t() + + @type delta :: pos_integer() + @type on_complete_callback :: (-> any()) + @type report_progress_callback :: (delta(), message() -> any()) + + defmacro __using__(_) do + quote do + import unquote(__MODULE__), only: [with_progress: 2] + end + end + + @spec with_progress(label(), (-> any())) :: any() + def with_progress(label, func) when is_function(func, 0) do + on_complete = begin_progress(label) + + try do + func.() + after + on_complete.() + end + end + + @spec with_percent_progress(label(), pos_integer(), (report_progress_callback() -> any())) :: + any() + def with_percent_progress(label, max, func) when is_function(func, 1) do + {report_progress, on_complete} = begin_percent(label, max) + + try do + func.(report_progress) + after + on_complete.() + end + end + + @spec begin_progress(label :: label()) :: on_complete_callback() + def begin_progress(label) do + Engine.broadcast(project_progress(label: label, stage: :begin)) + + fn -> + Engine.broadcast(project_progress(label: label, stage: :complete)) + end + end + + @spec begin_percent(label(), pos_integer()) :: + {report_progress_callback(), on_complete_callback()} + def begin_percent(label, max) do + Engine.broadcast(percent_progress(label: label, max: max, stage: :begin)) + + report_progress = fn delta, message -> + Engine.broadcast( + percent_progress(label: label, message: message, delta: delta, stage: :report) + ) + end + + complete = fn -> + Engine.broadcast(percent_progress(label: label, stage: :complete)) + end + + {report_progress, complete} + end +end diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex new file mode 100644 index 00000000..425885b3 --- /dev/null +++ b/engine/lib/engine/project_node.ex @@ -0,0 +1,244 @@ +defmodule Engine.ProjectNode do + alias Forge.Project + + require Logger + + defmodule State do + defstruct [ + :project, + :port, + :cookie, + :stopped_by, + :stop_timeout, + :started_by, + :status + ] + + def new(%Project{} = project) do + cookie = Node.get_cookie() + + %__MODULE__{ + project: project, + cookie: cookie, + status: :initializing + } + end + + @dialyzer {:nowarn_function, start: 3} + + def start(%__MODULE__{} = state, paths, from) do + this_node = inspect(Node.self()) + + args = [ + "--name", + Project.node_name(state.project), + "--cookie", + state.cookie, + "--no-halt", + "-e", + "Node.connect(#{this_node})" + | path_append_arguments(paths) + ] + + port = Engine.Port.open_elixir(state.project, args: args) + + %{state | port: port, started_by: from} + end + + def stop(%__MODULE__{} = state, from, stop_timeout) do + project_rpc(state, System, :stop) + %{state | stopped_by: from, stop_timeout: stop_timeout, status: :stopping} + end + + def halt(%__MODULE__{} = state) do + project_rpc(state, System, :halt) + %{state | status: :stopped} + end + + def on_nodeup(%__MODULE__{} = state, node_name) do + if node_name == Project.node_name(state.project) do + {pid, _ref} = state.started_by + Process.monitor(pid) + GenServer.reply(state.started_by, :ok) + + %{state | status: :started} + else + state + end + end + + def on_nodedown(%__MODULE__{} = state, node_name) do + if node_name == Project.node_name(state.project) do + maybe_reply_to_stopper(state) + {:shutdown, %{state | status: :stopped}} + else + :continue + end + end + + def maybe_reply_to_stopper(%State{stopped_by: stopped_by} = state) + when is_tuple(stopped_by) do + GenServer.reply(state.stopped_by, :ok) + end + + def maybe_reply_to_stopper(%State{}), do: :ok + + def on_monitored_dead(%__MODULE__{} = state) do + if project_rpc(state, Node, :alive?) do + halt(state) + else + %{state | status: :stopped} + end + end + + defp path_append_arguments(paths) do + Enum.flat_map(paths, fn path -> + ["-pa", Path.expand(path)] + end) + end + + defp project_rpc(%__MODULE__{} = state, module, function, args \\ []) do + state.project + |> Project.node_name() + |> :rpc.call(module, function, args) + end + end + + alias Forge.Document + alias Engine.ProjectNodeSupervisor + use GenServer + + def start(project, paths) do + node_name = Project.node_name(project) + bootstrap_args = [project, Document.Store.entropy(), all_app_configs()] + + with {:ok, node_pid} <- ProjectNodeSupervisor.start_project_node(project), + :ok <- start_node(project, paths), + :ok <- :rpc.call(node_name, Engine.Bootstrap, :init, bootstrap_args) do + {:ok, node_pid} + end + end + + @stop_timeout 1_000 + + def stop(%Project{} = project, stop_timeout \\ @stop_timeout) do + project + |> name() + |> GenServer.call({:stop, stop_timeout}, stop_timeout + 100) + end + + def child_spec(%Project{} = project) do + %{ + id: name(project), + start: {__MODULE__, :start_link, [project]}, + restart: :transient + } + end + + def start_link(%Project{} = project) do + state = State.new(project) + GenServer.start_link(__MODULE__, state, name: name(project)) + end + + @start_timeout 3_000 + + defp start_node(project, paths) do + project + |> name() + |> GenServer.call({:start, paths}, @start_timeout + 500) + end + + @impl GenServer + def init(state) do + Process.flag(:trap_exit, true) + {:ok, state} + end + + @impl true + def handle_call({:start, paths}, from, %State{} = state) do + :ok = :net_kernel.monitor_nodes(true, node_type: :visible) + Process.send_after(self(), :maybe_start_timeout, @start_timeout) + state = State.start(state, paths, from) + {:noreply, state} + end + + @impl true + def handle_call({:stop, stop_timeout}, from, %State{} = state) do + state = State.stop(state, from, stop_timeout) + {:noreply, state, stop_timeout} + end + + @impl true + def handle_info({:nodeup, node, _}, %State{} = state) do + state = State.on_nodeup(state, node) + {:noreply, state} + end + + @impl true + def handle_info(:maybe_start_timeout, %State{status: :started} = state) do + {:noreply, state} + end + + @impl true + def handle_info(:maybe_start_timeout, %State{} = state) do + GenServer.reply(state.started_by, {:error, :start_timeout}) + {:stop, :start_timeout, nil} + end + + @impl true + def handle_info({:nodedown, node_name, _}, %State{} = state) do + case State.on_nodedown(state, node_name) do + {:shutdown, new_state} -> + {:stop, :shutdown, new_state} + + :continue -> + {:noreply, state} + end + end + + @impl true + def handle_info({:DOWN, _ref, :process, _object, _reason}, %State{} = state) do + state = State.on_monitored_dead(state) + {:stop, :shutdown, state} + end + + @impl true + def handle_info({:EXIT, port, reason}, %State{port: port} = state) do + Logger.info("Port #{inspect(port)} has exited due to: #{inspect(reason)}") + {:noreply, %State{state | port: nil}} + end + + @impl true + def handle_info({:EXIT, port, _}, state) when is_port(port) do + {:noreply, state} + end + + @impl true + def handle_info(:timeout, %State{} = state) do + state = State.halt(state) + State.maybe_reply_to_stopper(state) + {:stop, :shutdown, state} + end + + @impl true + def handle_info({_port, {:data, _message}}, %State{} = state) do + {:noreply, state} + end + + @impl true + def handle_info(msg, %State{} = state) do + Logger.warning("Received unexpected message #{inspect(msg)}") + {:noreply, state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::node_process" + end + + @deps_apps Mix.Project.deps_apps() + defp all_app_configs do + Enum.map(@deps_apps, fn app_name -> + {app_name, Application.get_all_env(app_name)} + end) + end +end diff --git a/engine/lib/engine/project_node_supervisor.ex b/engine/lib/engine/project_node_supervisor.ex new file mode 100644 index 00000000..59a69af3 --- /dev/null +++ b/engine/lib/engine/project_node_supervisor.ex @@ -0,0 +1,27 @@ +defmodule Engine.ProjectNodeSupervisor do + alias Forge.Project + alias Engine.ProjectNode + use DynamicSupervisor + + @dialyzer {:no_return, start_link: 1} + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + def start_link(%Project{} = project) do + DynamicSupervisor.start_link(__MODULE__, project, name: __MODULE__, strategy: :one_for_one) + end + + def start_project_node(%Project{} = project) do + DynamicSupervisor.start_child(__MODULE__, ProjectNode.child_spec(project)) + end + + @impl true + def init(_init_arg) do + DynamicSupervisor.init(strategy: :one_for_one) + end +end diff --git a/engine/lib/engine/worker.ex b/engine/lib/engine/worker.ex deleted file mode 100644 index 92817add..00000000 --- a/engine/lib/engine/worker.ex +++ /dev/null @@ -1,64 +0,0 @@ -defmodule Engine.Worker do - use GenServer - - def start_link(arg) do - GenServer.start_link(__MODULE__, arg, name: __MODULE__) - end - - @impl GenServer - def init(_arg) do - working_dir = File.cwd!() - {:ok, %{working_dir: working_dir}} - end - - def enqueue_compiler(opts) do - GenServer.cast(__MODULE__, {:compile, opts}) - end - - defp flush(acc) do - receive do - {:"$gen_cast", {:compile, opts}} -> flush([opts | acc]) - after - 0 -> acc - end - end - - @impl GenServer - def handle_cast({:compile, opts}, state) do - # we essentially compile now and rollup any newer requests to compile, so that we aren't doing 5 compiles - # if we the user saves 5 times after saving one time - flush([]) - from = Keyword.fetch!(opts, :from) - - File.cd!(state.working_dir) - - result = Engine.Worker.compile() - - Process.send(from, {:compiler_result, result}, []) - {:noreply, state} - end - - def compile do - # keep stdout on this node - Process.group_leader(self(), Process.whereis(:user)) - - Mix.Task.clear() - - # load the paths for deps and compile them - # will noop if they are already compiled - # The mix cli basically runs this before any mix task - # we have to rerun because we already ran a mix task - # (mix run), which called this, but we also passed - # --no-compile, so nothing was compiled, but the - # task was not re-enabled it seems - Mix.Task.rerun("deps.loadpaths") - - Mix.Task.rerun("compile", [ - "--ignore-module-conflict", - "--no-protocol-consolidation", - "--return-errors" - ]) - rescue - e -> {:error, e} - end -end diff --git a/engine/mix.exs b/engine/mix.exs index bf0a3e9c..94242c79 100644 --- a/engine/mix.exs +++ b/engine/mix.exs @@ -22,11 +22,15 @@ defmodule Engine.MixProject do # Run "mix help deps" to learn about dependencies. defp deps do [ + {:forge, path: "../forge"}, {:spitfire, "~> 0.1"}, + {:elixir_sense, github: "elixir-lsp/elixir_sense"}, + {:path_glob, "~> 0.2.0"}, + {:sourceror, "~> 1.0"}, # {:gen_lsp, "~> 0.10"}, {:gen_lsp, github: "elixir-tools/gen_lsp", branch: "change-schematic-function", override: true}, - {:namespace, path: "../namespace", only: [:dev, :prod], runtime: false} + {:namespace, path: "../namespace", runtime: false} ] end end diff --git a/engine/mix.lock b/engine/mix.lock index 91ee44f8..9130538a 100644 --- a/engine/mix.lock +++ b/engine/mix.lock @@ -1,9 +1,14 @@ %{ "beam_file": {:hex, :beam_file, "0.6.2", "efd54ec60be6a03f0a8f96f72b0353427196613289c46032d3500f0ab6c34d32", [:mix], [], "hexpm", "09a99e8e5aad674edcad7213b0d7602375dfd3c7d02f8e3136e3efae0bcc9c56"}, + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "809a0924b40562d3c779e481a3c8970a52640c21", []}, "gen_lsp": {:git, "https://github.com/elixir-tools/gen_lsp.git", "f63f284289ef61b678ab6bd2cbcf3a6ba3d9fcdd", [branch: "change-schematic-function"]}, "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"}, + "nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"}, + "path_glob": {:hex, :path_glob, "0.2.0", "b9e34b5045cac5ecb76ef1aa55281a52bf603bf7009002085de40958064ca312", [:mix], [{:nimble_parsec, "~> 1.2.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "be2594cb4553169a1a189f95193d910115f64f15f0d689454bb4e8cfae2e7ebc"}, "schematic": {:hex, :schematic, "0.2.1", "0b091df94146fd15a0a343d1bd179a6c5a58562527746dadd09477311698dbb1", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0b255d65921e38006138201cd4263fd8bb807d9dfc511074615cd264a571b3b1"}, + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, "spitfire": {:hex, :spitfire, "0.1.3", "7ea0f544005dfbe48e615ed90250c9a271bfe126914012023fd5e4b6b82b7ec7", [:mix], [], "hexpm", "d53b5107bcff526a05c5bb54c95e77b36834550affd5830c9f58760e8c543657"}, "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, "typed_struct": {:hex, :typed_struct, "0.3.0", "939789e3c1dca39d7170c87f729127469d1315dcf99fee8e152bb774b17e7ff7", [:mix], [], "hexpm", "c50bd5c3a61fe4e198a8504f939be3d3c85903b382bde4865579bc23111d1b6d"}, diff --git a/expert/lib/expert.ex b/expert/lib/expert.ex index 79ab39e6..707db4ff 100644 --- a/expert/lib/expert.ex +++ b/expert/lib/expert.ex @@ -1,15 +1,23 @@ defmodule Expert do + alias GenLSP.Enumerations.CodeActionKind + alias GenLSP.Structures.CodeActionOptions use GenLSP - require Logger - require Expert.Runtime - alias Expert.Runtime + alias GenLSP.Enumerations.TextDocumentSyncKind + alias GenLSP.Structures.SaveOptions + alias GenLSP.Structures.TextDocumentSyncOptions + alias GenLSP.Structures.ServerCapabilities + alias GenLSP.Structures.InitializeResult + alias GenLSP.Structures.InitializeParams + alias GenLSP.Requests.Initialize + + alias Expert.State + + require Logger def start_link(args) do {args, opts} = - Keyword.split(args, [ - :dynamic_supervisor - ]) + Keyword.split(args, [:dynamic_supervisor]) GenLSP.start_link(__MODULE__, args, opts) end @@ -22,103 +30,66 @@ defmodule Expert do assign(lsp, dynamic_supervisor: dynamic_supervisor, exit_code: 1, - client_capabilities: nil + client_capabilities: nil, + state: State.new() )} end @impl true def handle_request( - %GenLSP.Requests.Initialize{ - params: %GenLSP.Structures.InitializeParams{ + %Initialize{ + params: %InitializeParams{ root_uri: root_uri, workspace_folders: workspace_folders, capabilities: caps } - }, + } = request, lsp ) do - parent = self() - name = Path.basename(root_uri) - - working_dir = URI.parse(root_uri).path - - DynamicSupervisor.start_child( - lsp.assigns.dynamic_supervisor, - {Expert.Runtime.Supervisor, - path: Path.join(working_dir, ".expert-lsp"), - name: name, - lsp: lsp, - lsp_pid: parent, - runtime: [ - working_dir: working_dir, - uri: root_uri, - on_initialized: fn status -> - if status == :ready do - msg = {:runtime_ready, name, self()} - - Process.send(parent, msg, []) - else - send(parent, {:runtime_failed, name, status}) - end - end - ]} - ) + state = Expert.State.initialize(Expert.State.new(), request) {:reply, - %GenLSP.Structures.InitializeResult{ - capabilities: %GenLSP.Structures.ServerCapabilities{ - text_document_sync: %GenLSP.Structures.TextDocumentSyncOptions{ + %InitializeResult{ + capabilities: %ServerCapabilities{ + text_document_sync: %TextDocumentSyncOptions{ open_close: true, - save: %GenLSP.Structures.SaveOptions{include_text: true}, - change: GenLSP.Enumerations.TextDocumentSyncKind.incremental() + save: %SaveOptions{include_text: true}, + change: TextDocumentSyncKind.incremental() + }, + code_action_provider: %CodeActionOptions{ + code_action_kinds: [ + # TODO(mhanberg): add code actions from Next LS + CodeActionKind.quick_fix(), + CodeActionKind.source_organize_imports() + ] }, + code_lens_provider: %GenLSP.Structures.CodeLensOptions{ + resolve_provider: false + }, + completion_provider: %GenLSP.Structures.CompletionOptions{ + trigger_characters: [".", "@", "&", "%", "^", ":", "!", "-", "~"] + }, + definition_provider: true, document_symbol_provider: true, - workspace: %{ - workspace_folders: %GenLSP.Structures.WorkspaceFoldersServerCapabilities{ - supported: true, - change_notifications: true - } - } + document_formatting_provider: true, + execute_command_provider: %GenLSP.Structures.ExecuteCommandOptions{ + # TODO(mhanberg): add commands from Next LS + commands: ["Reindex"] + }, + hover_provider: true, + references_provider: true, + workspace_symbol_provider: true }, server_info: %{name: "Expert"} }, assign(lsp, root_uri: root_uri, workspace_folders: workspace_folders, - client_capabilities: caps + client_capabilities: caps, + state: state )} end - def handle_request( - %GenLSP.Requests.TextDocumentDocumentSymbol{params: %{text_document: %{uri: uri}}}, - lsp - ) do - path = URI.parse(uri).path - doc = File.read!(path) - - lsp = - if lsp.assigns[:runtime] == nil do - receive do - {:runtime_ready, _name, runtime_pid} = msg -> - send(self(), msg) - assign(lsp, ready: true, runtime: runtime_pid) - end - else - lsp - end - - symbols = - Expert.Runtime.execute! lsp.assigns.runtime do - Engine.DocumentSymbol.fetch(doc) - end - - # which then will get serialized again on the way out - # we could potentially namespace our app too, but i think that - # makes our dev experience worse - - {:reply, symbols, lsp} - end - def handle_request(%GenLSP.Requests.Shutdown{}, lsp) do {:reply, nil, assign(lsp, exit_code: 0)} end @@ -137,6 +108,8 @@ defmodule Expert do Logger.info("Log file located at #{Path.join(File.cwd!(), ".expert-lsp/expert.log")}") + Expert.Project.Supervisor.start() + {:noreply, lsp} end diff --git a/expert/lib/expert/api.ex b/expert/lib/expert/api.ex new file mode 100644 index 00000000..a2cd3f82 --- /dev/null +++ b/expert/lib/expert/api.ex @@ -0,0 +1,142 @@ +defmodule Expert.Api do + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Project + + alias Forge.CodeIntelligence + + require Logger + + def schedule_compile(%Project{} = project, force?) do + call(project, Engine, :schedule_compile, [force?]) + end + + def compile_document(%Project{} = project, %Document{} = document) do + call(project, Engine, :compile_document, [document]) + end + + def call(%Project{} = project, m, f, a \\ []) do + project + |> Forge.Project.node_name() + |> :erpc.call(m, f, a) + end + + def expand_alias( + %Project{} = project, + segments_or_module, + %Analysis{} = analysis, + %Position{} = position + ) do + Engine.call(project, Engine, :expand_alias, [ + segments_or_module, + analysis, + position + ]) + end + + def list_modules(%Project{} = project) do + Engine.call(project, Engine, :list_modules) + end + + def format(%Project{} = project, %Document{} = document) do + Engine.call(project, Engine, :format, [document]) + end + + def code_actions( + %Project{} = project, + %Document{} = document, + %Range{} = range, + diagnostics, + kinds + ) do + Engine.call(project, Engine, :code_actions, [ + document, + range, + diagnostics, + kinds + ]) + end + + def complete(%Project{} = project, %Env{} = env) do + Logger.info("Completion for #{inspect(env.position)}") + Engine.call(project, Engine, :complete, [env]) + end + + def complete_struct_fields(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + Engine.call(project, Engine, :complete_struct_fields, [ + analysis, + position + ]) + end + + def definition(%Project{} = project, %Document{} = document, %Position{} = position) do + Engine.call(project, Engine, :definition, [document, position]) + end + + def references( + %Project{} = project, + %Analysis{} = analysis, + %Position{} = position, + include_definitions? + ) do + Engine.call(project, Engine, :references, [ + analysis, + position, + include_definitions? + ]) + end + + def modules_with_prefix(%Project{} = project, prefix) + when is_binary(prefix) or is_atom(prefix) do + Engine.call(project, Engine, :modules_with_prefix, [prefix]) + end + + def modules_with_prefix(%Project{} = project, prefix, predicate) + when is_binary(prefix) or is_atom(prefix) do + Engine.call(project, Engine, :modules_with_prefix, [prefix, predicate]) + end + + @spec docs(Project.t(), module()) :: {:ok, CodeIntelligence.Docs.t()} | {:error, any()} + def docs(%Project{} = project, module, opts \\ []) when is_atom(module) do + Engine.call(project, Engine, :docs, [module, opts]) + end + + def register_listener(%Project{} = project, listener_pid, message_types) + when is_pid(listener_pid) and is_list(message_types) do + Engine.call(project, Engine, :register_listener, [ + listener_pid, + message_types + ]) + end + + def broadcast(%Project{} = project, message) do + Engine.call(project, Engine, :broadcast, [message]) + end + + def reindex(%Project{} = project) do + Engine.call(project, Engine, :reindex, []) + end + + def index_running?(%Project{} = project) do + Engine.call(project, Engine, :index_running?, []) + end + + def resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + Engine.call(project, Engine, :resolve_entity, [analysis, position]) + end + + def struct_definitions(%Project{} = project) do + Engine.call(project, Engine, :struct_definitions, []) + end + + def document_symbols(%Project{} = project, %Document{} = document) do + Engine.call(project, Engine, :document_symbols, [document]) + end + + def workspace_symbols(%Project{} = project, query) do + Engine.call(project, Engine, :workspace_symbols, [query]) + end +end diff --git a/expert/lib/expert/application.ex b/expert/lib/expert/application.ex index 41b8a763..3aa093ef 100644 --- a/expert/lib/expert/application.ex +++ b/expert/lib/expert/application.ex @@ -19,7 +19,13 @@ defmodule Expert.Application do Node.start(:"expert-#{System.system_time()}", :shortnames) - children = [Expert.LSPSupervisor] + children = [ + {Forge.Document.Store, derive: [analysis: &Forge.Ast.analyze/1]}, + Expert.LSPSupervisor, + {DynamicSupervisor, Expert.Project.Supervisor.options()}, + {Task.Supervisor, name: Expert.TaskQueue.task_supervisor_name()}, + TaskQueue + ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options diff --git a/expert/lib/expert/runtime/supervisor.ex b/expert/lib/expert/runtime/supervisor.ex deleted file mode 100644 index 5c6abcfe..00000000 --- a/expert/lib/expert/runtime/supervisor.ex +++ /dev/null @@ -1,26 +0,0 @@ -defmodule Expert.Runtime.Supervisor do - @moduledoc false - - use Supervisor - - def start_link(init_arg) do - Supervisor.start_link(__MODULE__, init_arg) - end - - @impl true - def init(init_arg) do - name = init_arg[:name] - lsp_pid = init_arg[:lsp_pid] - hidden_folder = init_arg[:path] - File.mkdir_p!(hidden_folder) - File.write!(Path.join(hidden_folder, ".gitignore"), "*\n") - - children = [ - {Expert.Runtime, - init_arg[:runtime] ++ - [name: name, parent: lsp_pid, lsp_pid: lsp_pid]} - ] - - Supervisor.init(children, strategy: :one_for_one) - end -end diff --git a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex new file mode 100644 index 00000000..e8c8dd84 --- /dev/null +++ b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex @@ -0,0 +1,94 @@ +defimpl Forge.Convertible, for: Forge.Plugin.V1.Diagnostic.Result do + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Lexical.Math + alias Forge.Plugin.V1.Diagnostic + alias Lexical.Protocol.Conversions + alias Lexical.Protocol.Types + alias Lexical.Text + + def to_lsp(%Diagnostic.Result{} = diagnostic) do + with {:ok, lsp_range} <- lsp_range(diagnostic) do + proto_diagnostic = %GenLSP.Structures.Diagnostic{ + message: diagnostic.message, + range: lsp_range, + severity: diagnostic.severity, + source: diagnostic.source + } + + {:ok, proto_diagnostic} + end + end + + def to_native(%Diagnostic.Result{} = diagnostic, _) do + {:ok, diagnostic} + end + + defp lsp_range(%Diagnostic.Result{position: %Position{} = position}) do + with {:ok, lsp_start_pos} <- Conversions.to_lsp(position) do + range = + Types.Range.new( + start: lsp_start_pos, + end: Types.Position.new(line: lsp_start_pos.line + 1, character: 0) + ) + + {:ok, range} + end + end + + defp lsp_range(%Diagnostic.Result{position: %Range{} = range}) do + Conversions.to_lsp(range) + end + + defp lsp_range(%Diagnostic.Result{uri: uri} = diagnostic) when is_binary(uri) do + with {:ok, document} <- Document.Store.open_temporary(uri) do + position_to_range(document, diagnostic.position) + end + end + + defp lsp_range(%Diagnostic.Result{}) do + {:error, :no_uri} + end + + defp position_to_range(%Document{} = document, {start_line, start_column, end_line, end_column}) do + start_pos = Position.new(document, start_line, max(start_column, 1)) + end_pos = Position.new(document, end_line, max(end_column, 1)) + + range = Range.new(start_pos, end_pos) + Conversions.to_lsp(range) + end + + defp position_to_range(%Document{} = document, {line_number, column}) do + column = max(column, 1) + + document + |> to_lexical_range(line_number, column) + |> Conversions.to_lsp() + end + + defp position_to_range(document, line_number) when is_integer(line_number) do + line_number = Math.clamp(line_number, 1, Document.size(document)) + + with {:ok, line_text} <- Document.fetch_text_at(document, line_number) do + column = Text.count_leading_spaces(line_text) + 1 + + document + |> to_lexical_range(line_number, column) + |> Conversions.to_lsp() + end + end + + defp position_to_range(document, nil) do + position_to_range(document, 1) + end + + defp to_lexical_range(%Document{} = document, line_number, column) do + line_number = Math.clamp(line_number, 1, Document.size(document) + 1) + + Range.new( + Position.new(document, line_number, column), + Position.new(document, line_number + 1, 1) + ) + end +end diff --git a/expert/lib/lexical/logging.ex b/expert/lib/lexical/logging.ex new file mode 100644 index 00000000..82c6c2e0 --- /dev/null +++ b/expert/lib/lexical/logging.ex @@ -0,0 +1,34 @@ +defmodule Lexical.Logging do + require Logger + + defmacro timed(label, do: block) do + if enabled?() do + quote do + timed_log(unquote(label), fn -> unquote(block) end) + end + else + block + end + end + + def timed_log(label, threshold_ms \\ 1, function) when is_function(function, 0) do + if enabled?() do + {elapsed_us, result} = :timer.tc(function) + elapsed_ms = elapsed_us / 1000 + + if elapsed_ms >= threshold_ms do + Logger.info("#{label} took #{Lexical.Formats.time(elapsed_us)}") + end + + result + else + function.() + end + end + + @debug_enabled? not is_nil(System.get_env("TIMINGS_ENABLED")) + + defp enabled? do + @debug_enabled? + end +end diff --git a/expert/lib/lexical/server.ex b/expert/lib/lexical/server.ex new file mode 100644 index 00000000..c954ac2a --- /dev/null +++ b/expert/lib/lexical/server.ex @@ -0,0 +1,198 @@ +# defmodule Expert do +# alias Lexical.Proto.Convert +# alias Lexical.Protocol.Notifications +# alias Lexical.Protocol.Requests +# alias Expert.Provider.Handlers +# alias Expert.State +# alias Expert.TaskQueue +# +# require Logger +# +# use GenServer +# +# @server_specific_messages [ +# Notifications.DidChange, +# Notifications.DidChangeConfiguration, +# Notifications.DidChangeWatchedFiles, +# Notifications.DidClose, +# Notifications.DidOpen, +# Notifications.DidSave, +# Notifications.Exit, +# Notifications.Initialized, +# Requests.Shutdown +# ] +# +# @dialyzer {:nowarn_function, apply_to_state: 2} +# +# @spec server_request( +# Requests.request(), +# (Requests.request(), {:ok, any()} | {:error, term()} -> term()) +# ) :: :ok +# def server_request(request, on_response) when is_function(on_response, 2) do +# GenServer.call(__MODULE__, {:server_request, request, on_response}) +# end +# +# @spec server_request(Requests.request()) :: :ok +# def server_request(request) do +# server_request(request, fn _, _ -> :ok end) +# end +# +# def start_link(_) do +# GenServer.start_link(__MODULE__, [], name: __MODULE__) +# end +# +# def protocol_message(message) do +# GenServer.cast(__MODULE__, {:protocol_message, message}) +# end +# +# def init(_) do +# {:ok, State.new()} +# end +# +# def handle_call({:server_request, request, on_response}, _from, %State{} = state) do +# new_state = State.add_request(state, request, on_response) +# {:reply, :ok, new_state} +# end +# +# def handle_cast({:protocol_message, message}, %State{} = state) do +# new_state = +# case handle_message(message, state) do +# {:ok, new_state} -> +# new_state +# +# error -> +# Logger.error( +# "Could not handle message #{inspect(message.__struct__)} #{inspect(error)}" +# ) +# +# state +# end +# +# {:noreply, new_state} +# end +# +# def handle_cast(other, %State{} = state) do +# Logger.info("got other: #{inspect(other)}") +# {:noreply, state} +# end +# +# def handle_info(:default_config, %State{configuration: nil} = state) do +# Logger.warning( +# "Did not receive workspace/didChangeConfiguration notification after 5 seconds. " <> +# "Using default settings." +# ) +# +# {:ok, config} = State.default_configuration(state) +# {:noreply, %State{state | configuration: config}} +# end +# +# def handle_info(:default_config, %State{} = state) do +# {:noreply, state} +# end +# +# def handle_message(%Requests.Initialize{} = initialize, %State{} = state) do +# Process.send_after(self(), :default_config, :timer.seconds(5)) +# +# case State.initialize(state, initialize) do +# {:ok, _state} = success -> +# success +# +# error -> +# {error, state} +# end +# end +# +# def handle_message(%Requests.Cancel{} = cancel_request, %State{} = state) do +# TaskQueue.cancel(cancel_request) +# {:ok, state} +# end +# +# def handle_message(%Notifications.Cancel{} = cancel_notification, %State{} = state) do +# TaskQueue.cancel(cancel_notification) +# {:ok, state} +# end +# +# def handle_message(%message_module{} = message, %State{} = state) +# when message_module in @server_specific_messages do +# case apply_to_state(state, message) do +# {:ok, _} = success -> +# success +# +# error -> +# Logger.error("Failed to handle #{message.__struct__}, #{inspect(error)}") +# end +# end +# +# def handle_message(nil, %State{} = state) do +# # NOTE: This deals with the response after a request is requested by the server, +# # such as the response of `CreateWorkDoneProgress`. +# {:ok, state} +# end +# +# def handle_message(%_{} = request, %State{} = state) do +# with {:ok, handler} <- fetch_handler(request), +# {:ok, req} <- Convert.to_native(request) do +# TaskQueue.add(request.id, {handler, :handle, [req, state.configuration]}) +# else +# {:error, {:unhandled, _}} -> +# Logger.info("Unhandled request: #{request.method}") +# +# _ -> +# :ok +# end +# +# {:ok, state} +# end +# +# def handle_message(%{} = response, %State{} = state) do +# new_state = State.finish_request(state, response) +# +# {:ok, new_state} +# end +# +# defp apply_to_state(%State{} = state, %{} = request_or_notification) do +# case State.apply(state, request_or_notification) do +# {:ok, new_state} -> {:ok, new_state} +# :ok -> {:ok, state} +# error -> {error, state} +# end +# end +# +# # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity +# defp fetch_handler(%_{} = request) do +# case request do +# %Requests.FindReferences{} -> +# {:ok, Handlers.FindReferences} +# +# %Requests.Formatting{} -> +# {:ok, Handlers.Formatting} +# +# %Requests.CodeAction{} -> +# {:ok, Handlers.CodeAction} +# +# %Requests.CodeLens{} -> +# {:ok, Handlers.CodeLens} +# +# %Requests.Completion{} -> +# {:ok, Handlers.Completion} +# +# %Requests.GoToDefinition{} -> +# {:ok, Handlers.GoToDefinition} +# +# %Requests.Hover{} -> +# {:ok, Handlers.Hover} +# +# %Requests.ExecuteCommand{} -> +# {:ok, Handlers.Commands} +# +# %Requests.DocumentSymbols{} -> +# {:ok, Handlers.DocumentSymbols} +# +# %Requests.WorkspaceSymbol{} -> +# {:ok, Handlers.WorkspaceSymbol} +# +# %request_module{} -> +# {:error, {:unhandled, request_module}} +# end +# end +# end diff --git a/expert/lib/lexical/server/application.ex b/expert/lib/lexical/server/application.ex new file mode 100644 index 00000000..204b2593 --- /dev/null +++ b/expert/lib/lexical/server/application.ex @@ -0,0 +1,32 @@ +# defmodule Expert.Application do +# # See https://hexdocs.pm/elixir/Application.html +# # for more information on OTP Applications +# @moduledoc false +# +# alias Forge.Document +# alias Expert +# alias Expert.TaskQueue +# alias Expert.Transport +# +# use Application +# +# @impl true +# def start(_type, _args) do +# children = [ +# document_store_child_spec(), +# Server, +# {DynamicSupervisor, Server.Project.Supervisor.options()}, +# {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, +# TaskQueue, +# {Transport.StdIO, [:standard_io, &Server.protocol_message/1]} +# ] +# +# opts = [strategy: :one_for_one, name: Server.Supervisor] +# Supervisor.start_link(children, opts) +# end +# +# @doc false +# def document_store_child_spec do +# {Document.Store, derive: [analysis: &Lexical.Ast.analyze/1]} +# end +# end diff --git a/expert/lib/lexical/server/code_intelligence/completion.ex b/expert/lib/lexical/server/code_intelligence/completion.ex new file mode 100644 index 00000000..4d3da6d4 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion.ex @@ -0,0 +1,367 @@ +defmodule Expert.CodeIntelligence.Completion do + alias Future.Code, as: Code + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document.Position + alias Forge.Project + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.Configuration + alias Expert.Project.Intelligence + alias GenLSP.Structures.CompletionContext + alias GenLSP.Structures.CompletionItem + + require Logger + + @lexical_deps Enum.map([:lexical | Mix.Project.deps_apps()], &Atom.to_string/1) + + @lexical_dep_modules Enum.map(@lexical_deps, &Macro.camelize/1) + + def trigger_characters do + [".", "@", "&", "%", "^", ":", "!", "-", "~"] + end + + @spec complete(Project.t(), Analysis.t(), Position.t(), Completion.Context.t()) :: + Completion.List.t() + def complete( + %Project{} = project, + %Analysis{} = analysis, + %Position{} = position, + %CompletionContext{} = context + ) do + case Env.new(project, analysis, position) do + {:ok, env} -> + completions = completions(project, env, context) + log_candidates(completions) + maybe_to_completion_list(completions) + + {:error, _} = error -> + Logger.error("Failed to build completion env #{inspect(error)}") + maybe_to_completion_list() + end + end + + defp log_candidates(candidates) do + log_iolist = + Enum.reduce(candidates, ["Emitting Completions: ["], fn %CompletionItem{} = completion, + acc -> + name = Map.get(completion, :name) || Map.get(completion, :label) + kind = completion |> Map.get(:kind, :unknown) |> to_string() + + [acc, [kind, ":", name], " "] + end) + + Logger.info([log_iolist, "]"]) + end + + defp completions(%Project{} = project, %Env{} = env, %CompletionContext{} = context) do + prefix_tokens = Env.prefix_tokens(env, 1) + + cond do + prefix_tokens == [] or not should_emit_completions?(env) -> + [] + + should_emit_do_end_snippet?(env) -> + do_end_snippet = "do\n $0\nend" + + env + |> Builder.snippet( + do_end_snippet, + label: "do/end block", + filter_text: "do" + ) + |> List.wrap() + + Env.in_context?(env, :struct_field_key) -> + project + |> Engine.Api.complete_struct_fields(env.analysis, env.position) + |> Enum.map(&Translatable.translate(&1, Builder, env)) + + true -> + project + |> Engine.Api.complete(env) + |> to_completion_items(project, env, context) + end + end + + defp should_emit_completions?(%Env{} = env) do + if inside_comment?(env) or inside_string?(env) do + false + else + always_emit_completions?() or has_meaningful_completions?(env) + end + end + + defp always_emit_completions? do + # If VS Code receives an empty completion list, it will never issue + # a new request, even if `is_incomplete: true` is specified. + # https://github.com/lexical-lsp/lexical/issues/400 + Configuration.get().client_name == "Visual Studio Code" + end + + defp has_meaningful_completions?(%Env{} = env) do + case Code.Fragment.cursor_context(env.prefix) do + :none -> + false + + {:unquoted_atom, name} -> + length(name) > 1 + + {:local_or_var, name} -> + local_length = length(name) + surround_begin = max(1, env.position.character - local_length) + + local_length > 1 or has_surround_context?(env.prefix, 1, surround_begin) + + _ -> + true + end + end + + defp inside_comment?(env) do + Env.in_context?(env, :comment) + end + + defp inside_string?(env) do + Env.in_context?(env, :string) + end + + defp has_surround_context?(fragment, line, column) + when is_binary(fragment) and line >= 1 and column >= 1 do + Code.Fragment.surround_context(fragment, {line, column}) != :none + end + + # We emit a do/end snippet if the prefix token is the do operator or 'd', and + # there is a space before the token preceding it on the same line. This + # handles situations like `@do|` where a do/end snippet would be invalid. + defguardp valid_do_prefix(kind, value) + when (kind === :identifier and value === ~c"d") or + (kind === :operator and value === :do) + + defguardp space_before_preceding_token(do_col, preceding_col) + when do_col - preceding_col > 1 + + defp should_emit_do_end_snippet?(%Env{} = env) do + prefix_tokens = Env.prefix_tokens(env, 2) + + valid_prefix? = + match?( + [{kind, value, {line, do_col}}, {_, _, {line, preceding_col}}] + when space_before_preceding_token(do_col, preceding_col) and + valid_do_prefix(kind, value), + prefix_tokens + ) + + valid_prefix? and Env.empty?(env.suffix) + end + + defp to_completion_items( + local_completions, + %Project{} = project, + %Env{} = env, + %CompletionContext{} = context + ) do + debug_local_completions(local_completions) + + for result <- local_completions, + displayable?(project, result), + applies_to_context?(project, result, context), + applies_to_env?(env, result), + %CompletionItem{} = item <- to_completion_item(result, env) do + item + end + end + + defp debug_local_completions(completions) do + completions_by_type = + Enum.group_by(completions, fn %candidate_module{} -> + candidate_module + |> Atom.to_string() + |> String.split(".") + |> List.last() + |> String.downcase() + end) + + log_iodata = + Enum.reduce(completions_by_type, ["Local completions are: ["], fn {type, completions}, + acc -> + names = + Enum.map_join(completions, ", ", fn candidate -> + Map.get(candidate, :name) || Map.get(candidate, :detail) + end) + + [acc, [type, ": (", names], ") "] + end) + + Logger.info([log_iodata, "]"]) + end + + defp to_completion_item(candidate, env) do + candidate + |> Translatable.translate(Builder, env) + |> List.wrap() + end + + defp displayable?(%Project{} = project, result) do + suggested_module = + case result do + %_{full_name: full_name} when is_binary(full_name) -> full_name + %_{origin: origin} when is_binary(origin) -> origin + _ -> "" + end + + cond do + Namespace.Module.prefixed?(suggested_module) -> + false + + # If we're working on the dependency, we should include it! + Project.name(project) in @lexical_deps -> + true + + true -> + Enum.reduce_while(@lexical_dep_modules, true, fn module, _ -> + if String.starts_with?(suggested_module, module) do + {:halt, false} + else + {:cont, true} + end + end) + end + end + + defp applies_to_env?(%Env{} = env, %struct_module{} = result) do + cond do + Env.in_context?(env, :struct_reference) -> + struct_reference_completion?(result, env) + + Env.in_context?(env, :bitstring) -> + struct_module in [Candidate.BitstringOption, Candidate.Variable] + + Env.in_context?(env, :alias) -> + struct_module in [ + Candidate.Behaviour, + Candidate.Module, + Candidate.Protocol, + Candidate.Struct + ] + + Env.in_context?(env, :use) -> + # only allow modules that define __using__ in a use statement + usable?(env, result) + + Env.in_context?(env, :impl) -> + # only allow behaviour modules after @impl + behaviour?(env, result) + + Env.in_context?(env, :spec) or Env.in_context?(env, :type) -> + typespec_or_type_candidate?(result, env) + + true -> + struct_module != Candidate.Typespec + end + end + + defp usable?(%Env{} = env, completion) do + # returns true if the given completion is or is a parent of + # a module that defines __using__ + case completion do + %{full_name: full_name} -> + with_prefix = + Engine.Api.modules_with_prefix( + env.project, + full_name, + {Kernel, :macro_exported?, [:__using__, 1]} + ) + + not Enum.empty?(with_prefix) + + _ -> + false + end + end + + defp behaviour?(%Env{} = env, completion) do + # returns true if the given completion is or is a parent of + # a module that is a behaviour + + case completion do + %{full_name: full_name} -> + with_prefix = + Engine.Api.modules_with_prefix( + env.project, + full_name, + {Kernel, :function_exported?, [:behaviour_info, 1]} + ) + + not Enum.empty?(with_prefix) + + _ -> + false + end + end + + defp struct_reference_completion?(%Candidate.Struct{}, _) do + true + end + + defp struct_reference_completion?(%Candidate.Module{} = module, %Env{} = env) do + Intelligence.defines_struct?(env.project, module.full_name, to: :great_grandchild) + end + + defp struct_reference_completion?(%Candidate.Macro{name: "__MODULE__"}, _) do + true + end + + defp struct_reference_completion?(_, _) do + false + end + + defp typespec_or_type_candidate?(%struct_module{}, _) + when struct_module in [Candidate.Module, Candidate.Typespec, Candidate.ModuleAttribute] do + true + end + + defp typespec_or_type_candidate?(%Candidate.Function{} = function, %Env{} = env) do + case Engine.Api.expand_alias(env.project, [:__MODULE__], env.analysis, env.position) do + {:ok, expanded} -> + expanded == function.origin + + _error -> + false + end + end + + defp typespec_or_type_candidate?(_, _) do + false + end + + @trigger_character GenLSP.Enumerations.CompletionTriggerKind.trigger_character() + defp applies_to_context?(%Project{} = project, result, %CompletionContext{ + trigger_kind: @trigger_character, + trigger_character: "%" + }) do + case result do + %Candidate.Module{} = result -> + Intelligence.defines_struct?(project, result.full_name, from: :child, to: :child) + + %Candidate.Struct{} -> + true + + _other -> + false + end + end + + defp applies_to_context?(_project, _result, _context) do + true + end + + defp maybe_to_completion_list(items \\ []) + + defp maybe_to_completion_list([]) do + Completion.List.new(items: [], is_incomplete: true) + end + + defp maybe_to_completion_list(items), do: items +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/builder.ex b/expert/lib/lexical/server/code_intelligence/completion/builder.ex new file mode 100644 index 00000000..445e1c75 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/builder.ex @@ -0,0 +1,195 @@ +defmodule Expert.CodeIntelligence.Completion.Builder do + @moduledoc """ + Completion builder. + + For broader compatibility and control, this builder always creates text + edits, as opposed to simple text insertions. This allows the replacement + range to be adjusted based on the kind of completion. + + When completions are built using `plain_text/3` or `snippet/3`, the + replacement range will be determined by the preceding token. + """ + + alias Future.Code, as: Code + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + alias GenLSP.Structures.CompletionItem + alias GenLSP.Structures.MarkupContent + alias Expert.CodeIntelligence.Completion.SortScope + + @doc "Fields found in `t:GenLSP.Structures.CompletionItem.t()`" + @type item_opts :: keyword() + + @type t :: module() + + @type line_range :: {start_character :: pos_integer, end_character :: pos_integer} + + @spec snippet(Env.t(), String.t(), item_opts) :: CompletionItem.t() + def snippet(%Env{} = env, text, options \\ []) do + range = prefix_range(env) + text_edit_snippet(env, text, range, options) + end + + @spec plain_text(Env.t(), String.t(), item_opts) :: CompletionItem.t() + def plain_text(%Env{} = env, text, options \\ []) do + range = prefix_range(env) + text_edit(env, text, range, options) + end + + @spec text_edit(Env.t(), String.t(), line_range, item_opts) :: CompletionItem.t() + def text_edit(%Env{} = env, text, {start_char, end_char}, options \\ []) do + line_number = env.position.line + + range = + Range.new( + Position.new(env.document, line_number, start_char), + Position.new(env.document, line_number, end_char) + ) + + edits = Document.Changes.new(env.document, Edit.new(text, range)) + + options + |> Keyword.put(:text_edit, edits) + |> then(&struct(CompletionItem, &1)) + |> markdown_docs() + |> set_sort_scope(SortScope.default()) + end + + @spec text_edit_snippet(Env.t(), String.t(), line_range, item_opts) :: CompletionItem.t() + def text_edit_snippet(%Env{} = env, text, {start_char, end_char}, options \\ []) do + snippet = String.trim_trailing(text, "\n") + line_number = env.position.line + + range = + Range.new( + Position.new(env.document, line_number, start_char), + Position.new(env.document, line_number, end_char) + ) + + edits = Document.Changes.new(env.document, Edit.new(snippet, range)) + + options + |> Keyword.put(:text_edit, edits) + |> Keyword.put(:insert_text_format, :snippet) + |> then(&struct(CompletionItem, &1)) + |> markdown_docs() + |> set_sort_scope(SortScope.default()) + end + + @spec fallback(any, any) :: any + def fallback(nil, fallback), do: fallback + def fallback("", fallback), do: fallback + def fallback(detail, _), do: detail + + @spec set_sort_scope(CompletionItem.t(), sort_scope :: String.t()) :: CompletionItem.t() + def set_sort_scope(item, default \\ SortScope.default()) + + def set_sort_scope(%CompletionItem{} = item, sort_scope) + when is_binary(sort_scope) do + stripped_sort_text = + item.sort_text + |> fallback(item.label) + |> strip_sort_text() + + sort_text = "0#{sort_scope}_#{stripped_sort_text}" + %CompletionItem{item | sort_text: sort_text} + end + + # private + + defp prefix_range(%Env{} = env) do + end_char = env.position.character + start_char = end_char - prefix_length(env) + {start_char, end_char} + end + + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + defp prefix_length(%Env{} = env) do + case Code.Fragment.cursor_context(env.prefix) do + {:alias, alias_charlist} -> + alias_charlist + |> :string.split(~c".", :all) + |> List.last() + |> length() + + {:alias, {:local_or_var, _}, alias_charlist} -> + length(alias_charlist) + + {:alias, {:module_attribute, _}, alias_charlist} -> + length(alias_charlist) + + {:dot, _inside_dot, charlist} -> + length(charlist) + + {:dot_arity, _inside_dot, charlist} -> + length(charlist) + + {:dot_call, _inside_dot, _charlist} -> + 0 + + :expr -> + String.length(env.prefix) + + {:local_or_var, local} -> + length(local) + + {:local_arity, local} -> + length(local) + + {:local_call, call} -> + length(call) + + {:module_attribute, attr} -> + length(attr) + + {:operator, operator} -> + length(operator) + + {:operator_arity, _} -> + 0 + + {:operator_call, _} -> + 0 + + {:sigil, sigil} -> + # The sigil charlist doesn't include the leading `~` + length(sigil) + 1 + + {:struct, struct} -> + length(struct) + + :none -> + 0 + + {:unquoted_atom, atom} -> + # add one to include the leading colon, which isn't included + # in the atom charlist + length(atom) + 1 + end + end + + @sort_prefix_re ~r/^[0-9_]+/ + defp strip_sort_text(sort_text) do + String.replace(sort_text, @sort_prefix_re, "") + end + + defp markdown_docs(%CompletionItem{} = item) do + case item.documentation do + doc when is_binary(doc) -> + # FIXME: fix the content kind + %{ + item + | documentation: %MarkupContent{ + kind: GenLSP.Enumerations.MarkupKind.markdown(), + value: doc + } + } + + _ -> + item + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex b/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex new file mode 100644 index 00000000..a2bc44db --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex @@ -0,0 +1,77 @@ +defmodule Expert.CodeIntelligence.Completion.SortScope do + @moduledoc """ + Enumerated categories for sorting completion items. + + The following options are available for all categories, spare variables + which cannot be deprecated. + * `deprecated?` - Indicates the completion is for a deprecated declaration. + Defaults to `false`. + + * `local_priority` - An integer from 0-9 highest-to-lowest for + prioritizing/sorting results within a given scope. Defaults to `1`. + """ + + @doc """ + Intended for module completions, such as `Lexical.` -> `Lexical.Completion`. + """ + def module(local_priority \\ 1) do + "0" <> "0" <> local_priority(local_priority) + end + + @doc """ + Intended for variables, which are always local in scope. + """ + def variable(local_priority \\ 1) do + "1" <> "0" <> local_priority(local_priority) + end + + @doc """ + Intended for declarations (functions and macros) defined in the immediate + module, or inherited from invoking `use`. + """ + def local(deprecated? \\ false, local_priority \\ 1) do + "2" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Intended for delcarations defined in other modules than the immediate scope, + either from one's project, dependencies, or the standard library. + """ + def remote(deprecated? \\ false, local_priority \\ 1) do + "3" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Intended for declarations available without aliasing, namely those in + `Kernel` and `Kernel.SpecialForms`. + """ + def global(deprecated? \\ false, local_priority \\ 1) do + "4" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Aspirationally for declarations that could be auto-aliased into the user's + immediate module (not yet a feature of Lexical). + """ + def auto(deprecated? \\ false, local_priority \\ 1) do + "5" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Sorting scope applied to completions that without any sorting scope applied. + """ + def default(deprecated? \\ false, local_priority \\ 1) do + "9" <> extra_order_fields(deprecated?, local_priority) + end + + defp extra_order_fields(deprecated?, local_priority) do + deprecated(deprecated?) <> local_priority(local_priority) + end + + defp deprecated(false), do: "0" + defp deprecated(true), do: "1" + + defp local_priority(x) when x in 0..9 do + Integer.to_string(x) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translatable.ex b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex new file mode 100644 index 00000000..d391eb71 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex @@ -0,0 +1,19 @@ +defprotocol Expert.CodeIntelligence.Completion.Translatable do + alias Forge.Ast.Env + alias GenLSP.Structures.CompletionItem + alias Expert.CodeIntelligence.Completion.Builder + + @type t :: any() + + @type translated :: [CompletionItem.t()] | CompletionItem.t() | :skip + + @fallback_to_any true + @spec translate(t, Builder.t(), Env.t()) :: translated + def translate(item, builder, env) +end + +defimpl Expert.CodeIntelligence.Completion.Translatable, for: Any do + def translate(_any, _builder, _environment) do + :skip + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex new file mode 100644 index 00000000..159ea892 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex @@ -0,0 +1,25 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.BitstringOption do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + require Logger + + defimpl Translatable, for: Candidate.BitstringOption do + def translate(option, builder, %Env{} = env) do + Translations.BitstringOption.translate(option, builder, env) + end + end + + def translate(%Candidate.BitstringOption{} = option, builder, %Env{} = env) do + env + |> builder.plain_text(option.name, + filter_text: option.name, + kind: :unit, + label: option.name + ) + |> builder.set_sort_scope(SortScope.global()) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex new file mode 100644 index 00000000..74e87b48 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex @@ -0,0 +1,222 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Callable do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.SortScope + + @callables [Candidate.Function, Candidate.Macro, Candidate.Callback, Candidate.Typespec] + + @syntax_macros ~w(= == == === =~ .. ..// ! != !== &&) + + def completion(%_callable_module{name: name} = callable, %Env{} = env) + when name in @syntax_macros do + if String.ends_with?(env.prefix, "Kernel.") do + do_completion(callable, env) + else + :skip + end + end + + def completion(%callable_module{arity: 0} = callable, %Env{} = env) + when callable_module in @callables do + unless Env.in_context?(env, :pipe) do + do_completion(callable, env) + end + end + + def completion(%callable_module{} = callable, %Env{} = env) + when callable_module in @callables do + do_completion(callable, env) + end + + # for a callable to be local, it must be defined in the current scope, + # or be a callback. + defp do_completion(callable, %Env{} = env) do + add_args? = not String.contains?(env.suffix, "(") + + insert_text = + if add_args? do + callable_snippet(callable, env) + else + callable.name + end + + tags = + if Map.get(callable.metadata, :deprecated) do + [:deprecated] + end + + kind = + case callable do + %Candidate.Typespec{} -> + :type_parameter + + _ -> + :function + end + + detail = + if callback?(callable) do + "(callback)" + else + "(#{callable.type})" + end + + env + |> Builder.snippet(insert_text, + label: label(callable, env), + kind: kind, + detail: detail, + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable), + tags: tags + ) + |> maybe_boost(callable, env) + end + + def capture_completions(%callable_module{} = callable, %Env{} = env) + when callable_module in @callables do + name_and_arity = name_and_arity(callable) + + complete_capture = + env + |> Builder.plain_text(name_and_arity, + label: name_and_arity, + kind: :function, + detail: "(Capture)", + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable) + ) + |> maybe_boost(callable, env) + + call_capture = + env + |> Builder.snippet(callable_snippet(callable, env), + label: label(callable, env), + kind: :function, + detail: "(Capture with arguments)", + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable) + ) + |> maybe_boost(callable, env) + + [complete_capture, call_capture] + end + + defp argument_names(%_{arity: 0}, _env) do + [] + end + + defp argument_names(%_{} = callable, %Env{} = env) do + if Env.in_context?(env, :pipe) do + tl(callable.argument_names) + else + callable.argument_names + end + end + + defp callable_snippet(%_{} = callable, env) do + argument_templates = + callable + |> argument_names(env) + |> Enum.with_index(1) + |> Enum.map_join(", ", fn {name, index} -> + "${#{index}:#{name}}" + end) + + if callable.parens? do + "#{callable.name}(#{argument_templates})" + else + "#{callable.name} #{argument_templates}" + end + end + + @default_functions ["module_info", "behaviour_info"] + + defp maybe_boost(item, callable, %Env{} = env) do + position_module = env.position_module + + %_{ + name: name, + origin: origin, + metadata: metadata + } = callable + + # elixir_sense suggests child_spec as a callback, though it's not formally one. + deprecated? = Map.has_key?(metadata, :deprecated) + dunder? = String.starts_with?(name, "__") + callback? = callback?(callable) + + local_priority = + cond do + dunder? -> 9 + callback? -> 8 + true -> 1 + end + + cond do + origin === "Kernel" or origin === "Kernel.SpecialForms" or name in @default_functions -> + local_priority = if dunder?, do: 9, else: 1 + Builder.set_sort_scope(item, SortScope.global(deprecated?, local_priority)) + + origin === position_module -> + Builder.set_sort_scope(item, SortScope.local(deprecated?, local_priority)) + + true -> + Builder.set_sort_scope(item, SortScope.remote(deprecated?, local_priority)) + end + end + + defp label(%_{} = callable, env) do + arg_detail = callable |> argument_names(env) |> Enum.join(", ") + + if callable.parens? do + "#{callable.name}(#{arg_detail})" + else + "#{callable.name} #{arg_detail}" + end + end + + defp name_and_arity(%_{name: name, arity: arity}) do + "#{name}/#{arity}" + end + + defp sort_text(%_callable{name: name, arity: arity}) do + normalized_arity = + arity + |> Integer.to_string() + |> String.pad_leading(3, "0") + + # we used to use : as a separator between the name and + # arity, but this caused bang functions to sort + # before non-bang variants, which is incorrect. + # Using a space sorts correctly, as it's the only ascii + # character lower than bang + + "#{name} #{normalized_arity}" + end + + defp build_docs(%{summary: summary, spec: spec}) + when is_binary(summary) and is_binary(spec) do + "#{summary}\n```elixir\n#{spec}\n```" + end + + defp build_docs(%{summary: summary}) when is_binary(summary) do + summary + end + + defp build_docs(%{spec: spec}) when is_binary(spec) do + "```elixir\n#{spec}\n```" + end + + defp build_docs(_) do + "" + end + + defp callback?(%_{name: name, metadata: metadata} = _callable) do + Map.has_key?(metadata, :implementing) || name === "child_spec" + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex new file mode 100644 index 00000000..6598745f --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex @@ -0,0 +1,103 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Callback do + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Completion.Candidate.Callback + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Callback do + def translate(callback, _builder, %Env{} = env) do + %Callback{ + name: name, + argument_names: arg_names, + summary: summary + } = callback + + %Env{line: line} = env + + env + |> Builder.text_edit_snippet( + insert_text(name, arg_names, env), + line_range(line), + label: label(name, arg_names), + kind: :interface, + detail: detail(callback), + sort_text: sort_text(callback), + filter_text: "def #{name}", + documentation: summary + ) + |> Builder.set_sort_scope(SortScope.local()) + end + + defp insert_text(name, arg_names, env) + when is_binary(name) and is_list(arg_names) do + impl_line(name, env) <> + "def #{name}(#{arg_text(arg_names)}) do" <> + "\n $0\nend" + end + + # add tab stops and join with ", " + defp arg_text(args) do + args + |> Enum.with_index(fn arg, i -> + "${#{i + 1}:#{arg}}" + end) + |> Enum.join(", ") + end + + # elixir_sense suggests child_spec/1 as a callback as it's a common idiom, + # but not an actual callback of behaviours like GenServer. + defp impl_line("child_spec", _env), do: "" + + # It's generally safe adding `@impl true` to callbacks as Elixir warns + # of conflicting behaviours, and they're virtually non-existent anyway. + defp impl_line(_, %Env{} = env) do + with {:ok, line_before} <- Document.fetch_text_at(env.document, env.position.line - 1), + true <- line_before =~ "@impl" do + "" + else + _ -> "@impl true\n" + end + end + + defp line_range(line) when is_binary(line) do + start_char = + case String.split(line, "def", parts: 2) do + [i, _] -> String.length(i) + 1 + [_] -> 0 + end + + end_char = String.length(line) + 1 + + {start_char, end_char} + end + + defp label(name, arg_names) + when is_binary(name) and is_list(arg_names) do + "#{name}(#{Enum.join(arg_names, ", ")})" + end + + defp detail(%Callback{name: "child_spec"}) do + "supervision specification" + end + + defp detail(%Callback{origin: origin, metadata: %{optional: false}}) do + "#{origin} callback (required)" + end + + defp detail(%Callback{origin: origin}) do + "#{origin} callback" + end + + # cribbed from the Callable translation for now. + defp sort_text(%Callback{name: name, arity: arity}) do + normalized_arity = + arity + |> Integer.to_string() + |> String.pad_leading(3, "0") + + "#{name}:#{normalized_arity}" + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex new file mode 100644 index 00000000..1ef5dcb2 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex @@ -0,0 +1,16 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Function do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.Function do + def translate(function, _builder, %Env{} = env) do + if Env.in_context?(env, :function_capture) do + Translations.Callable.capture_completions(function, env) + else + Translations.Callable.completion(function, env) + end + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex new file mode 100644 index 00000000..4349dc4c --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex @@ -0,0 +1,678 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Macro do + alias Lexical.Ast + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Position + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + alias Expert.CodeIntelligence.Completion.Translations.Callable + alias Expert.CodeIntelligence.Completion.Translations.Struct + + @snippet_macros ~w(def defp defmacro defmacrop defimpl defmodule defprotocol defguard defguardp defexception test use) + @unhelpful_macros ~w(:: alias! in and or destructure) + + defimpl Translatable, for: Candidate.Macro do + def translate(macro, builder, %Env{} = env) do + Translations.Macro.translate(macro, builder, env) + end + end + + def translate(%Candidate.Macro{name: name}, _builder, _env) + when name in ["__before_compile__", "__using__", "__after_compile__"] do + :skip + end + + def translate(%Candidate.Macro{name: "def", arity: 2} = macro, builder, env) do + function_snippet("def", "define a function", macro, builder, env) + end + + def translate(%Candidate.Macro{name: "defp", arity: 2} = macro, builder, env) do + function_snippet("defp", "define a private function", macro, builder, env) + end + + def translate(%Candidate.Macro{name: "defmodule"} = macro, builder, env) do + label = "defmodule (define a module)" + suggestion = suggest_module_name(env.document) + + snippet = """ + defmodule ${1:#{suggestion}} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defmacro", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a macro)" + + snippet = """ + defmacro ${1:name}($2) do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defmacrop", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a private macro)" + + snippet = """ + defmacrop ${1:name}($2) do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defprotocol"} = macro, builder, env) do + label = "#{macro.name} (define a protocol)" + + snippet = """ + defprotocol ${1:protocol_name} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defimpl", arity: 3} = macro, builder, env) do + label = "#{macro.name} (define a protocol implementation)" + + snippet = """ + defimpl ${1:protocol_name}, for: ${2:struct_name} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defoverridable"} = macro, builder, env) do + label = "#{macro.name} (mark a function as overridable)" + + snippet = "defoverridable ${1:keyword_or_behaviour}" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defdelegate", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a delegate function)" + + snippet = "defdelegate ${1:call}(${2:args}), to: ${3:module}" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defguard", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a guard macro)" + + snippet = "defguard ${1:guard}(${2:args}) when $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defguardp", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a private guard macro)" + + snippet = "defguardp ${1:guard}(${2:args}) when $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defexception", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define an exception)" + + snippet = "defexception [${1::message}]" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defstruct", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a struct)" + + snippet = "defstruct [${1:fields}]" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "alias", arity: 2} = macro, builder, env) do + label = "#{macro.name} (alias a module's name)" + + snippet = "alias $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "use", arity: 1}, builder, env) do + label = "use (invoke another module's __using__ macro)" + snippet = "use $0" + + env + |> builder.snippet(snippet, + kind: :class, + label: label, + filter_text: "use" + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "require" <> _, arity: 2} = macro, builder, env) do + label = "#{macro.name} (require a module's macros)" + + snippet = "require $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "quote" <> _, arity: 2} = macro, builder, env) do + label = "#{macro.name} (quote block)" + + snippet = """ + quote $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "receive" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (receive block)" + + snippet = """ + receive do + ${1:pattern} -> $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "try" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (try / catch / rescue block)" + + snippet = """ + try do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "with" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (with statement)" + + snippet = """ + with ${1:pattern} <- ${2:expression} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "case", arity: 2} = macro, builder, env) do + label = "#{macro.name} (case statement)" + + snippet = """ + case $1 do + ${2:pattern} -> $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "if", arity: 2} = macro, builder, env) do + label = "#{macro.name} (if statement)" + + snippet = """ + if $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "import", arity: 2} = macro, builder, env) do + label = "#{macro.name} (import a module's functions)" + + snippet = "import $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "unless", arity: 2} = macro, builder, env) do + label = "#{macro.name} (unless statement)" + + snippet = """ + unless $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "cond"} = macro, builder, env) do + label = "#{macro.name} (cond statement)" + + snippet = """ + cond do + ${1:test} -> + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "for"} = macro, builder, env) do + label = "#{macro.name} (comprehension)" + + snippet = """ + for ${1:pattern} <- ${2:enumerable} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + @stub_label ~S(test "message" ) + @plain_label ~S(test "message" do... ) + @context_label ~S(test "message", %{} do...) + + def translate(%Candidate.Macro{name: "test", arity: 1}, builder, env) do + stub_label = @stub_label + + stub_snippet = ~S(test "${0:message}") + + env + |> builder.snippet(stub_snippet, + detail: "A stub test", + kind: :class, + label: stub_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 2)) + end + + def translate(%Candidate.Macro{name: "test", arity: 2}, builder, env) do + plain_label = @plain_label + + plain_snippet = """ + test "${1:message}" do + $0 + end + """ + + env + |> builder.snippet(plain_snippet, + detail: "A test", + kind: :class, + label: plain_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 0)) + end + + def translate(%Candidate.Macro{name: "test", arity: 3}, builder, env) do + context_label = @context_label + + context_snippet = """ + test "${1:message}", %{${2:context}} do + $0 + end + """ + + env + |> builder.snippet(context_snippet, + detail: "A test that receives context", + kind: :class, + label: context_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 1)) + end + + def translate(%Candidate.Macro{name: "describe"}, builder, env) do + snippet = """ + describe "${1:message}" do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: "A describe block", + kind: :class, + label: ~S(describe "message"), + filter_text: "describe" + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "__MODULE__"} = macro, builder, env) do + if Env.in_context?(env, :struct_reference) do + Struct.completion(env, builder, macro.name, macro.name) + else + env + |> builder.plain_text("__MODULE__", + detail: macro.spec, + kind: :constant, + label: "__MODULE__", + filter_text: "__MODULE__" + ) + |> builder.set_sort_scope(SortScope.global()) + end + end + + def translate(%Candidate.Macro{name: dunder_form} = macro, builder, env) + when dunder_form in ~w(__CALLER__ __DIR__ __ENV__ __MODULE__ __STACKTRACE__) do + env + |> builder.plain_text(dunder_form, + detail: macro.spec, + kind: :constant, + label: dunder_form, + filter_text: dunder_form + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: dunder_form}, _builder, _env) + when dunder_form in ~w(__aliases__ __block__) do + :skip + end + + def translate(%Candidate.Macro{name: name}, _builder, _env) + when name in @unhelpful_macros do + :skip + end + + def translate(%Candidate.Macro{name: name} = macro, _builder, env) + when name not in @snippet_macros do + Callable.completion(macro, env) + end + + def translate(%Candidate.Macro{}, _builder, _env) do + :skip + end + + defp function_snippet(kind, label, %Candidate.Macro{} = macro, builder, env) do + label = "#{macro.name} (#{label})" + + snippet = + with {:ok, %Position{} = position} <- Env.prev_significant_position(env), + {:ok, name, args} <- extract_spec_name_and_args(env, position) do + args_snippet = + case suggest_arg_names(args) do + [] -> + "" + + names -> + placeholders = + names + |> Enum.with_index(1) + |> Enum.map_join(", ", fn {name, i} -> "${#{i}:#{name}}" end) + + "(" <> placeholders <> ")" + end + + """ + #{kind} #{name}#{args_snippet} do + $0 + end + """ + else + _ -> + """ + #{kind} ${1:name}($2) do + $0 + end + """ + end + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + defp extract_spec_name_and_args(%Env{} = env, %Position{} = position) do + with {:ok, [maybe_spec | _]} <- Ast.path_at(env.analysis, position), + {:@, _, [{:spec, _, [typespec]}]} <- maybe_spec, + {:"::", _, [{name, _, args}, _return]} <- typespec do + if is_list(args) do + {:ok, name, args} + else + {:ok, name, []} + end + else + _ -> :error + end + end + + defp suggest_arg_names(args) do + Enum.with_index(args, fn + {:"::", _, [{name, _, nil}, _]}, _i when is_atom(name) -> name + _, i -> "arg_#{i + 1}" + end) + end + + defp suggest_module_name(%Document{} = document) do + result = + document.path + |> Path.split() + |> Enum.reduce(false, fn + "lib", _ -> + {:lib, []} + + "test", _ -> + {:test, []} + + "support", {:test, _} -> + {:lib, []} + + _, false -> + false + + element, {type, elements} -> + camelized = camelize_file_name(element) + + {type, [camelized | elements]} + end) + + case result do + {_, parts} -> + parts + |> Enum.reverse() + |> Enum.join(".") + + false -> + document.path + |> Path.basename() + |> camelize_file_name() + end + end + + defp camelize_file_name(file_name_with_extension) do + file_name_with_extension + |> Path.rootname() + |> String.split(".") + |> Enum.map_join(".", &Macro.camelize/1) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex new file mode 100644 index 00000000..fee3495e --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex @@ -0,0 +1,27 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.MapField do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Candidate.MapField do + def translate(%Candidate.MapField{} = map_field, builder, %Env{} = env) do + builder.text_edit(env, map_field.name, range(env), + detail: map_field.name, + label: map_field.name, + kind: :field + ) + end + + defp range(%Env{} = env) do + case Env.prefix_tokens(env, 1) do + # ensure the text edit doesn't overwrite the dot operator + # when we're completing immediately after it: some_map.| + [{:operator, :., {_line, char}}] -> + {char + 1, env.position.character} + + [{_, _, {_line, char}}] -> + {char, env.position.character} + end + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex new file mode 100644 index 00000000..26d7f29c --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex @@ -0,0 +1,178 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.ModuleAttribute do + alias Lexical.Ast + alias Forge.Ast.Env + alias Forge.Document.Position + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.ModuleAttribute do + def translate(attribute, builder, %Env{} = env) do + Translations.ModuleAttribute.translate(attribute, builder, env) + end + end + + def translate(%Candidate.ModuleAttribute{name: "@moduledoc"}, builder, env) do + doc_snippet = ~s''' + @moduledoc """ + $0 + """ + ''' + + case fetch_range(env) do + {:ok, range} -> + with_doc = + builder.text_edit_snippet(env, doc_snippet, range, + detail: "Document public module", + kind: :property, + label: "@moduledoc" + ) + + without_doc = + builder.text_edit(env, "@moduledoc false", range, + detail: "Mark as private", + kind: :property, + label: "@moduledoc false" + ) + + [with_doc, without_doc] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{name: "@doc"}, builder, env) do + doc_snippet = ~s''' + @doc """ + $0 + """ + ''' + + case fetch_range(env) do + {:ok, range} -> + with_doc = + builder.text_edit_snippet(env, doc_snippet, range, + detail: "Document public function", + kind: :property, + label: "@doc" + ) + + without_doc = + builder.text_edit(env, "@doc false", range, + detail: "Mark as private", + kind: :property, + label: "@doc false" + ) + + [with_doc, without_doc] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{name: "@spec"}, builder, env) do + case fetch_range(env) do + {:ok, range} -> + [ + maybe_specialized_spec_snippet(builder, env, range), + basic_spec_snippet(builder, env, range) + ] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{} = attribute, builder, env) do + case fetch_range(env) do + {:ok, range} -> + builder.text_edit(env, attribute.name, range, + detail: "module attribute", + kind: :constant, + label: attribute.name + ) + + :error -> + :skip + end + end + + defp fetch_range(%Env{} = env) do + case fetch_at_op_on_same_line(env) do + {:ok, {:at_op, _, {_line, char}}} -> + {:ok, {char, env.position.character}} + + _ -> + :error + end + end + + defp fetch_at_op_on_same_line(%Env{} = env) do + Enum.reduce_while(Env.prefix_tokens(env), :error, fn + {:at_op, _, _} = at_op, _acc -> + {:halt, {:ok, at_op}} + + {:eol, _, _}, _acc -> + {:halt, :error} + + _, acc -> + {:cont, acc} + end) + end + + defp maybe_specialized_spec_snippet(builder, %Env{} = env, range) do + with {:ok, %Position{} = position} <- Env.next_significant_position(env), + {:ok, [{maybe_def, _, [call, _]} | _]} when maybe_def in [:def, :defp] <- + Ast.path_at(env.analysis, position), + {function_name, _, args} <- call do + specialized_spec_snippet(builder, env, range, function_name, args) + else + _ -> nil + end + end + + defp specialized_spec_snippet(builder, env, range, function_name, args) do + name = to_string(function_name) + + args_snippet = + case args do + nil -> + "" + + list -> + Enum.map_join(1..length(list), ", ", &"${#{&1}:term()}") + end + + snippet = ~s""" + @spec #{name}(#{args_snippet}) :: ${0:term()} + """ + + env + |> builder.text_edit_snippet(snippet, range, + detail: "Typespec", + kind: :property, + label: "@spec #{name}" + ) + |> builder.set_sort_scope(SortScope.global(false, 0)) + end + + defp basic_spec_snippet(builder, env, range) do + snippet = ~S""" + @spec ${1:function}(${2:term()}) :: ${3:term()} + def ${1:function}(${4:args}) do + $0 + end + """ + + env + |> builder.text_edit_snippet(snippet, range, + detail: "Typespec", + kind: :property, + label: "@spec" + ) + |> builder.set_sort_scope(SortScope.global(false, 1)) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex new file mode 100644 index 00000000..d5cea99b --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex @@ -0,0 +1,145 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.ModuleOrBehaviour do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + alias Expert.Project.Intelligence + + defimpl Translatable, for: Candidate.Module do + def translate(module, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(module, builder, env) + end + end + + defimpl Translatable, for: Candidate.Struct do + def translate(module, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(module, builder, env) + end + end + + defimpl Translatable, for: Candidate.Behaviour do + def translate(behaviour, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(behaviour, builder, env) + end + end + + defimpl Translatable, for: Candidate.Protocol do + def translate(protocol, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(protocol, builder, env) + end + end + + def translate(%_{} = module, builder, %Env{} = env) do + if Env.in_context?(env, :struct_reference) do + complete_in_struct_reference(env, builder, module) + else + detail = builder.fallback(module.summary, module.full_name) + completion(env, builder, module.name, detail) + end + end + + defp complete_in_struct_reference(%Env{} = env, builder, %Candidate.Struct{} = struct) do + immediate_descendent_structs = + immediate_descendent_struct_modules(env.project, struct.full_name) + + if Enum.empty?(immediate_descendent_structs) do + Translations.Struct.completion(env, builder, struct.name, struct.full_name) + else + do_complete_in_struct_reference(env, builder, struct, immediate_descendent_structs) + end + end + + defp complete_in_struct_reference(%Env{} = env, builder, %Candidate.Module{} = module) do + immediate_descendent_structs = + immediate_descendent_struct_modules(env.project, module.full_name) + + do_complete_in_struct_reference(env, builder, module, immediate_descendent_structs) + end + + defp do_complete_in_struct_reference( + %Env{} = env, + builder, + module_or_struct, + immediate_descendent_structs + ) do + structs_mapset = MapSet.new(immediate_descendent_structs) + dot_counts = module_dot_counts(module_or_struct.full_name) + ancestors = ancestors(immediate_descendent_structs, dot_counts) + + Enum.flat_map(ancestors, fn ancestor -> + local_name = local_module_name(module_or_struct.full_name, ancestor, module_or_struct.name) + + more = + env.project + |> Intelligence.collect_struct_modules(ancestor, to: :infinity) + |> Enum.count() + + if struct?(ancestor, structs_mapset) do + [ + Translations.Struct.completion(env, builder, local_name, ancestor), + Translations.Struct.completion(env, builder, local_name, ancestor, more - 1) + ] + else + [Translations.Struct.completion(env, builder, local_name, ancestor, more)] + end + end) + end + + defp struct?(module, structs_mapset) do + MapSet.member?(structs_mapset, module) + end + + defp ancestors(results, dot_counts) do + results + |> Enum.map(fn module -> + module |> String.split(".") |> Enum.take(dot_counts + 1) |> Enum.join(".") + end) + |> Enum.uniq() + end + + # this skips grapheme translations + defp module_dot_counts(module_name), do: module_dot_counts(module_name, 0) + + defp module_dot_counts(<<>>, count), do: count + defp module_dot_counts(<<".", rest::binary>>, count), do: module_dot_counts(rest, count + 1) + defp module_dot_counts(<<_::utf8, rest::binary>>, count), do: module_dot_counts(rest, count) + + def completion(%Env{} = env, builder, module_name, detail \\ nil) do + detail = builder.fallback(detail, "#{module_name} (Module)") + + env + |> builder.plain_text(module_name, label: module_name, kind: :module, detail: detail) + |> builder.set_sort_scope(SortScope.module()) + end + + defp local_module_name(parent_module, child_module, aliased_module) do + # Returns the "local" module name, so if you're completing + # Types.Som and the module completion is "Types.Something.Else", + # "Something.Else" is returned. + + parent_pieces = String.split(parent_module, ".") + parent_pieces = Enum.take(parent_pieces, length(parent_pieces) - 1) + local_module_name = Enum.join(parent_pieces, ".") + local_module_length = String.length(local_module_name) + + local_name = + child_module + |> String.slice(local_module_length..-1//1) + |> strip_leading_period() + + if String.starts_with?(local_name, aliased_module) do + local_name + else + [_ | tail] = String.split(local_name, ".") + Enum.join([aliased_module | tail], ".") + end + end + + defp strip_leading_period(<<".", rest::binary>>), do: rest + defp strip_leading_period(string_without_period), do: string_without_period + + defp immediate_descendent_struct_modules(%Forge.Project{} = project, module_name) do + Intelligence.collect_struct_modules(project, module_name, to: :grandchild) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex new file mode 100644 index 00000000..2a52baeb --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex @@ -0,0 +1,93 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Struct do + alias Future.Code, as: Code + alias Forge.Ast.Env + alias Lexical.Formats + + def completion(%Env{} = _env, _builder, _module_name, _full_name, 0) do + nil + end + + def completion(%Env{} = env, builder, module_name, full_name, more) when is_integer(more) do + singular = "${count} more struct" + plural = "${count} more structs" + + builder_opts = [ + kind: :module, + label: "#{module_name}...(#{Formats.plural(more, singular, plural)})", + detail: "#{full_name}." + ] + + insert_text = "#{module_name}." + range = edit_range(env) + + builder.text_edit_snippet(env, insert_text, range, builder_opts) + end + + def completion(%Env{} = env, builder, struct_name, full_name) do + builder_opts = [ + kind: :struct, + detail: "#{full_name}", + label: "#{struct_name}" + ] + + range = edit_range(env) + + insert_text = + if add_curlies?(env) do + struct_name <> "{$1}" + else + struct_name + end + + builder.text_edit_snippet(env, insert_text, range, builder_opts) + end + + defp add_curlies?(%Env{} = env) do + if Env.in_context?(env, :struct_reference) do + not String.contains?(env.suffix, "{") + else + false + end + end + + defp edit_range(%Env{} = env) do + prefix_end = env.position.character + + edit_begin = + case Code.Fragment.cursor_context(env.prefix) do + {:struct, {:dot, {:alias, _typed_module}, _rest}} -> + prefix_end + + {:struct, typed_module_name} -> + beginning_of_edit(env, typed_module_name) + + {:local_or_var, [?_ | _rest] = typed} -> + beginning_of_edit(env, typed) + end + + {edit_begin, env.position.character} + end + + defp beginning_of_edit(env, typed_module_name) do + case left_offset_of(typed_module_name, ?.) do + {:ok, offset} -> + env.position.character - offset + + :error -> + env.position.character - length(typed_module_name) + end + end + + defp left_offset_of(string, character) do + string + |> Enum.reverse() + |> Enum.with_index() + |> Enum.reduce_while(:error, fn + {^character, index}, _ -> + {:halt, {:ok, index}} + + _, acc -> + {:cont, acc} + end) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex new file mode 100644 index 00000000..7f91f5b8 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex @@ -0,0 +1,57 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.StructField do + alias Future.Code, as: Code + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.StructField do + def translate(field, builder, %Env{} = env) do + Translations.StructField.translate(field, builder, env) + end + end + + def translate(%Candidate.StructField{name: "__struct__"}, _builder, _env) do + :skip + end + + def translate(%Candidate.StructField{call?: false} = struct_field, builder, %Env{} = env) do + name = struct_field.name + value = to_string(name) + + builder_opts = [ + kind: :field, + label: "#{name}: #{value}", + filter_text: "#{name}:" + ] + + insert_text = "#{name}: ${1:#{value}}" + range = edit_range(env) + + env + |> builder.text_edit_snippet(insert_text, range, builder_opts) + |> builder.set_sort_scope(SortScope.variable()) + end + + def translate(%Candidate.StructField{} = struct_field, builder, %Env{} = env) do + builder.plain_text(env, struct_field.name, + detail: struct_field.type_spec, + label: struct_field.name, + kind: :field + ) + end + + def edit_range(env) do + prefix_end = env.position.character + + case Code.Fragment.cursor_context(env.prefix) do + {:local_or_var, field_char} -> + edit_begin = env.position.character - length(field_char) + {edit_begin, prefix_end} + + _ -> + {prefix_end, prefix_end} + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex new file mode 100644 index 00000000..18831862 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex @@ -0,0 +1,12 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Typespec do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations.Callable + + defimpl Translatable, for: Candidate.Typespec do + def translate(typespec, _builder, %Env{} = env) do + Callable.completion(typespec, env) + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex new file mode 100644 index 00000000..5a3a945b --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex @@ -0,0 +1,18 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Variable do + alias Forge.Ast.Env + alias Forge.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Candidate.Variable do + def translate(variable, builder, %Env{} = env) do + env + |> builder.plain_text(variable.name, + detail: variable.name, + kind: :variable, + label: variable.name + ) + |> builder.set_sort_scope(SortScope.variable()) + end + end +end diff --git a/expert/lib/lexical/server/configuration.ex b/expert/lib/lexical/server/configuration.ex new file mode 100644 index 00000000..fa683e2d --- /dev/null +++ b/expert/lib/lexical/server/configuration.ex @@ -0,0 +1,139 @@ +defmodule Expert.Configuration do + @moduledoc """ + Encapsulates server configuration options and client capability support. + """ + + alias Forge.Project + alias GenLSP.Notifications.WorkspaceDidChangeConfiguration + alias GenLSP.Structures.ClientCapabilities + alias Lexical.Protocol.Types.Registration + alias Expert.Configuration.Support + alias Expert.Dialyzer + + defstruct project: nil, + support: nil, + client_name: nil, + additional_watched_extensions: nil, + dialyzer_enabled?: false + + @type t :: %__MODULE__{ + project: Project.t() | nil, + support: support | nil, + client_name: String.t() | nil, + additional_watched_extensions: [String.t()] | nil, + dialyzer_enabled?: boolean() + } + + @opaque support :: Support.t() + + @dialyzer {:nowarn_function, set_dialyzer_enabled: 2} + + @spec new(Lexical.uri(), map(), String.t() | nil) :: t + def new(root_uri, %ClientCapabilities{} = client_capabilities, client_name) do + support = Support.new(client_capabilities) + project = Project.new(root_uri) + + %__MODULE__{support: support, project: project, client_name: client_name} + |> tap(&set/1) + end + + @spec new(keyword()) :: t + def new(attrs \\ []) do + struct!(__MODULE__, [support: Support.new()] ++ attrs) + end + + defp set(%__MODULE__{} = config) do + :persistent_term.put(__MODULE__, config) + end + + @spec get() :: t + def get do + :persistent_term.get(__MODULE__, false) || new() + end + + @spec client_supports?(atom()) :: boolean() + def client_supports?(key) when is_atom(key) do + client_supports?(get().support, key) + end + + defp client_supports?(%Support{} = client_support, key) do + case Map.fetch(client_support, key) do + {:ok, value} -> value + :error -> raise ArgumentError, "unknown key: #{inspect(key)}" + end + end + + @spec default(t | nil) :: + {:ok, t} + | {:ok, t, Requests.RegisterCapability.t()} + def default(nil) do + {:ok, default_config()} + end + + def default(%__MODULE__{} = config) do + apply_config_change(config, default_config()) + end + + @spec on_change(t, DidChangeConfiguration.t()) :: + {:ok, t} + | {:ok, t, Requests.RegisterCapability.t()} + def on_change(%__MODULE__{} = old_config, :defaults) do + apply_config_change(old_config, default_config()) + end + + def on_change(%__MODULE__{} = old_config, %WorkspaceDidChangeConfiguration{} = change) do + apply_config_change(old_config, change.lsp.settings) + end + + defp default_config do + %{} + end + + defp apply_config_change(%__MODULE__{} = old_config, %{} = settings) do + old_config + |> set_dialyzer_enabled(settings) + |> maybe_add_watched_extensions(settings) + end + + defp set_dialyzer_enabled(%__MODULE__{} = old_config, settings) do + enabled? = + if Dialyzer.check_support() == :ok do + Map.get(settings, "dialyzerEnabled", true) + else + false + end + + %__MODULE__{old_config | dialyzer_enabled?: enabled?} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, %{ + "additionalWatchedExtensions" => [] + }) do + {:ok, old_config} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, %{ + "additionalWatchedExtensions" => extensions + }) + when is_list(extensions) do + register_id = Id.next() + request_id = Id.next() + + watchers = Enum.map(extensions, fn ext -> %{"globPattern" => "**/*#{ext}"} end) + + registration = + Registration.new( + id: request_id, + method: "workspace/didChangeWatchedFiles", + register_options: %{"watchers" => watchers} + ) + + request = RegisterCapability.new(id: register_id, registrations: [registration]) + + {:ok, old_config, request} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, _) do + {:ok, old_config} + end +end diff --git a/expert/lib/lexical/server/configuration/support.ex b/expert/lib/lexical/server/configuration/support.ex new file mode 100644 index 00000000..a6420069 --- /dev/null +++ b/expert/lib/lexical/server/configuration/support.ex @@ -0,0 +1,71 @@ +defmodule Expert.Configuration.Support do + @moduledoc false + + alias GenLSP.Structures.ClientCapabilities + + # To track a new client capability, add a new field and the path to the + # capability in the `Lexical.Protocol.Types.ClientCapabilities` struct + # to this mapping: + @client_capability_mapping [ + code_action_dynamic_registration: [ + :text_document, + :code_action, + :dynamic_registration + ], + hierarchical_symbols: [ + :text_document, + :document_symbol, + :hierarchical_document_symbol_support + ], + snippet: [ + :text_document, + :completion, + :completion_item, + :snippet_support + ], + deprecated: [ + :text_document, + :completion, + :completion_item, + :deprecated_support + ], + tags: [ + :text_document, + :completion, + :completion_item, + :tag_support + ], + signature_help: [ + :text_document, + :signature_help + ], + work_done_progress: [ + :window, + :work_done_progress + ] + ] + + defstruct code_action_dynamic_registration: false, + hierarchical_symbols: false, + snippet: false, + deprecated: false, + tags: false, + signature_help: false, + work_done_progress: false + + @type t :: %__MODULE__{} + + def new(%ClientCapabilities{} = client_capabilities) do + defaults = + for {key, path} <- @client_capability_mapping do + value = get_in(client_capabilities, path) || false + {key, value} + end + + struct(__MODULE__, defaults) + end + + def new do + %__MODULE__{} + end +end diff --git a/expert/lib/lexical/server/dialyzer.ex b/expert/lib/lexical/server/dialyzer.ex new file mode 100644 index 00000000..fa7d575b --- /dev/null +++ b/expert/lib/lexical/server/dialyzer.ex @@ -0,0 +1,5 @@ +defmodule Expert.Dialyzer do + def check_support do + :ok + end +end diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex new file mode 100644 index 00000000..15462d3b --- /dev/null +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -0,0 +1,267 @@ +defmodule Expert.IEx.Helpers do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Position + alias Forge.Project + alias Lexical.Protocol.Types.Completion + alias Engine + alias Forge.Search + alias Expert.CodeIntelligence + + defmacro __using__(_) do + quote do + alias Forge.Document + alias Forge.Document.Position + alias Engine + alias Forge.Search + import unquote(__MODULE__) + + Forge.Module.Loader.start_link(nil) + Forge.Dispatch.start_link([]) + end + end + + def observer do + # credo:disable-for-next-line + apply(:observer, :start, []) + end + + def observer(project) do + project + |> ensure_project() + |> Engine.call(:observer, :start) + end + + def doc(text) do + doc(:lexical, text) + end + + def project_node(name) do + name + |> project() + |> Project.node_name() + end + + def doc(project, text) do + root_path = + project + |> project() + |> Project.root_path() + + [root_path, "lib", "file.ex"] + |> Path.join() + |> Document.Path.to_uri() + |> Document.new(text, 0) + end + + def search_store(project) do + project = ensure_project(project) + Forge.set_project(project) + + Search.Store.start_link( + project, + &Search.Indexer.create_index/1, + &Search.Indexer.update_index/2, + Search.Store.Backends.Ets + ) + end + + def search_entries(project) do + {:ok, entries} = + project + |> ensure_project() + |> Search.Indexer.create_index() + + entries + end + + def pos(doc, line, character) do + Position.new(doc, line, character) + end + + def compile_project(project) do + project + |> ensure_project() + |> Engine.Api.schedule_compile(true) + end + + def compile_file(project, source) when is_binary(source) do + project + |> ensure_project() + |> compile_file(doc(source)) + end + + def compile_file(project, %Document{} = document) do + project + |> ensure_project() + |> Engine.Api.compile_document(document) + end + + def complete(project, source, context \\ nil) + + def complete(project, source, context) when is_binary(source) do + case completion_position(source) do + {:found, line, character} -> + analysis = source |> doc() |> Ast.analyze() + complete(project, analysis, line, character, context) + + other -> + other + end + end + + def complete(project, %Ast.Analysis{} = analysis, line, character, context) do + context = + if is_nil(context) do + Completion.Context.new(trigger_kind: :trigger_character) + else + context + end + + position = pos(analysis.document, line, character) + + project + |> ensure_project() + |> CodeIntelligence.Completion.complete(analysis, position, context) + end + + def connect do + manager_name = manager_name() + Node.start(:"r@127.0.0.1") + Node.set_cookie(:lexical) + Node.connect(:"#{manager_name}@127.0.0.1") + end + + @doc """ + Create a Lexical Project for an application in the same directory as + Lexical. + + Alternatively, a project for one of our test fixtures can be created + using the `fixture: true` option. + + ## Examples + + iex> project() + %Forge.Project{ + root_uri: "file:///.../lexical + ... + } + + iex> project(:my_project) + %Forge.Project{ + root_uri: "file:///.../my_project" + ... + } + + iex> project(:navigations, fixture: true) + %Forge.Project{ + root_uri: "file:///.../lexical/apps/remote_control/test/fixtures/navigations" + ... + } + + """ + def project(project \\ :lexical, opts \\ []) do + project = + if opts[:fixture] do + "lexical/apps/remote_control/test/fixtures/#{project}" + else + project + end + + # We're using a cache here because we need project's + # entropy to be the same after every call. + trans(project, fn -> + project_path = + [File.cwd!(), "..", to_string(project)] + |> Path.join() + |> Path.expand() + + project_uri = "file://#{project_path}" + Forge.Project.new(project_uri) + end) + end + + def current_project do + [prefix, _] = Node.self() |> to_string() |> String.split("@") + [_, project_name, entropy] = String.split(prefix, "-") + %{ensure_project(project_name) | entropy: entropy} + end + + def stop_project(project) do + project + |> ensure_project() + |> Expert.Project.Supervisor.stop() + end + + def start_project(project) do + project + |> ensure_project() + |> Expert.Project.Supervisor.start() + end + + def time(fun) when is_function(fun, 0) do + {elapsed_us, result} = :timer.tc(fun) + + IO.puts([ + IO.ANSI.format([:cyan, :bright, "Time: "]), + Lexical.Formats.time(elapsed_us) + ]) + + result + end + + defp manager_name do + {:ok, names} = :erl_epmd.names() + + names + |> Enum.map(fn {name, _port} -> List.to_string(name) end) + |> Enum.find(&String.starts_with?(&1, "manager")) + end + + defp completion_position(source_string) do + source_string + |> String.split(["\r\n", "\r", "\n"]) + |> Enum.with_index() + |> Enum.reduce_while(:not_found, fn {line, line_number}, _ -> + if String.contains?(line, "|") do + index = + line + |> String.graphemes() + |> Enum.find_index(&(&1 == "|")) + + {:halt, {:found, line_number + 1, index + 1}} + else + {:cont, :not_found} + end + end) + end + + defp ensure_project(%Project{} = project) do + project + end + + defp ensure_project(project) when is_binary(project) do + project + |> String.to_atom() + |> project() + end + + defp ensure_project(project) when is_atom(project) do + project(project) + end + + defp trans(name, function) do + name = {__MODULE__, name} + + case :persistent_term.get(name, :undefined) do + :undefined -> + value = function.() + :persistent_term.put(name, value) + + _ -> + :ok + end + + :persistent_term.get(name) + end +end diff --git a/expert/lib/lexical/server/project/diagnostics.ex b/expert/lib/lexical/server/project/diagnostics.ex new file mode 100644 index 00000000..28e49cae --- /dev/null +++ b/expert/lib/lexical/server/project/diagnostics.ex @@ -0,0 +1,106 @@ +defmodule Expert.Project.Diagnostics do + alias Lexical.Formats + alias Forge.Project + alias Lexical.Protocol.Notifications.PublishDiagnostics + alias Engine + alias Expert.Project.Diagnostics.State + alias Expert.Transport + + import Forge.Api.Messages + require Logger + use GenServer + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([%Project{} = project]) do + Engine.Api.register_listener(project, self(), [ + file_diagnostics(), + project_compile_requested(), + project_compiled(), + project_diagnostics() + ]) + + state = State.new(project) + {:ok, state} + end + + @impl GenServer + def handle_info(project_compile_requested(), %State{} = state) do + state = State.clear_all_flushed(state) + {:noreply, state} + end + + @impl GenServer + def handle_info( + project_diagnostics(build_number: build_number, diagnostics: diagnostics), + %State{} = state + ) do + state = + Enum.reduce(diagnostics, state, fn diagnostic, state -> + State.add(state, build_number, diagnostic) + end) + + publish_diagnostics(state) + + {:noreply, state} + end + + @impl GenServer + def handle_info( + file_diagnostics(uri: uri, build_number: build_number, diagnostics: diagnostics), + %State{} = state + ) do + state = + case diagnostics do + [] -> + State.clear(state, uri) + + diagnostics -> + Enum.reduce(diagnostics, state, fn diagnostic, state -> + State.add(state, build_number, diagnostic) + end) + end + + publish_diagnostics(state) + + {:noreply, state} + end + + @impl GenServer + def handle_info( + project_compiled(elapsed_ms: elapsed_ms), + %State{} = state + ) do + project_name = Project.name(state.project) + Logger.info("Compiled #{project_name} in #{Formats.time(elapsed_ms, unit: :millisecond)}") + + {:noreply, state} + end + + # Private + + defp publish_diagnostics(%State{} = state) do + Enum.each(state.entries_by_uri, fn {uri, %State.Entry{} = entry} -> + diagnostics_list = State.Entry.diagnostics(entry) + notification = PublishDiagnostics.new(uri: uri, diagnostics: diagnostics_list) + + Transport.write(notification) + end) + end + + defp name(%Project{} = project) do + :"#{Project.name(project)}::diagnostics" + end +end diff --git a/expert/lib/lexical/server/project/diagnostics/state.ex b/expert/lib/lexical/server/project/diagnostics/state.ex new file mode 100644 index 00000000..5eaa41a2 --- /dev/null +++ b/expert/lib/lexical/server/project/diagnostics/state.ex @@ -0,0 +1,103 @@ +defmodule Expert.Project.Diagnostics.State do + defmodule Entry do + defstruct build_number: 0, diagnostics: [] + + def new(build_number) when is_integer(build_number) do + %__MODULE__{build_number: build_number} + end + + def new(build_number, diagnostic) do + %__MODULE__{build_number: build_number, diagnostics: MapSet.new([diagnostic])} + end + + def add(%__MODULE__{} = entry, build_number, diagnostic) do + cond do + build_number < entry.build_number -> + entry + + build_number > entry.build_number -> + new(build_number, diagnostic) + + true -> + %__MODULE__{entry | diagnostics: MapSet.put(entry.diagnostics, diagnostic)} + end + end + + def diagnostics(%__MODULE__{} = entry) do + Enum.to_list(entry.diagnostics) + end + end + + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic + alias Forge.Project + + defstruct project: nil, entries_by_uri: %{} + + require Logger + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def get(%__MODULE__{} = state, source_uri) do + entry = Map.get(state.entries_by_uri, source_uri, Entry.new(0)) + Entry.diagnostics(entry) + end + + def clear(%__MODULE__{} = state, source_uri) do + new_entries = Map.put(state.entries_by_uri, source_uri, Entry.new(0)) + + %__MODULE__{state | entries_by_uri: new_entries} + end + + @doc """ + Only clear diagnostics if they've been synced to disk + It's possible that the diagnostic presented by typing is still correct, and the file + that exists on the disk is actually an older copy of the file in memory. + """ + def clear_all_flushed(%__MODULE__{} = state) do + cleared = + Map.new(state.entries_by_uri, fn {uri, %Entry{} = entry} -> + with true <- Document.Store.open?(uri), + {:ok, %Document{} = document} <- Document.Store.fetch(uri), + true <- keep_diagnostics?(document) do + {uri, entry} + else + _ -> + {uri, Entry.new(0)} + end + end) + + %__MODULE__{state | entries_by_uri: cleared} + end + + def add(%__MODULE__{} = state, build_number, %Diagnostic.Result{} = diagnostic) do + entries_by_uri = + Map.update( + state.entries_by_uri, + diagnostic.uri, + Entry.new(build_number, diagnostic), + fn entry -> + Entry.add(entry, build_number, diagnostic) + end + ) + + %__MODULE__{state | entries_by_uri: entries_by_uri} + end + + def add(%__MODULE__{} = state, _build_number, other) do + Logger.error("Invalid diagnostic: #{inspect(other)}") + state + end + + defp keep_diagnostics?(%Document{} = document) do + # Keep any diagnostics for script files, which aren't compiled) + # or dirty files, which have been modified after compilation has occurrend + document.dirty? or script_file?(document) + end + + defp script_file?(document) do + Path.extname(document.path) == ".exs" + end +end diff --git a/expert/lib/lexical/server/project/intelligence.ex b/expert/lib/lexical/server/project/intelligence.ex new file mode 100644 index 00000000..3bc8a977 --- /dev/null +++ b/expert/lib/lexical/server/project/intelligence.ex @@ -0,0 +1,245 @@ +defmodule Expert.Project.Intelligence do + defmodule State do + alias Lexical.Formats + alias Forge.Project + + defstruct project: nil, struct_modules: MapSet.new() + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def delete_struct_module(%__MODULE__{} = state, module_name) do + module_path = module_path(module_name) + + struct_modules = MapSet.delete(state.struct_modules, module_path) + %__MODULE__{state | struct_modules: struct_modules} + end + + def add_struct_module(%__MODULE__{} = state, module_name) do + module_path = module_path(module_name) + %__MODULE__{state | struct_modules: MapSet.put(state.struct_modules, module_path)} + end + + def descendent_defines_struct?(%__MODULE__{} = state, prefix, %Range{} = range) do + module_path = module_path(prefix) + Enum.any?(state.struct_modules, &prefixes_match?(module_path, &1, range)) + end + + def descendent_struct_modules(%__MODULE__{} = state, prefix, range_or_infinity) do + module_path = module_path(prefix) + + for struct_path <- state.struct_modules, + prefixes_match?(module_path, struct_path, range_or_infinity) do + Enum.join(struct_path, ".") + end + end + + defp module_path(module_name) do + module_name + |> Formats.module() + |> String.split(".") + end + + defp prefixes_match?([], _remainder, :infinity) do + true + end + + defp prefixes_match?([], remainder, %Range{} = range) do + length(remainder) in range + end + + defp prefixes_match?([same | haystack], [same | needle], range) do + prefixes_match?(haystack, needle, range) + end + + defp prefixes_match?(_, _, _) do + false + end + end + + alias Forge.Project + alias Expert.Api + + use GenServer + import Forge.Api.Messages + + @generations [ + :self, + :child, + :grandchild, + :great_grandchild, + :great_great_grandchild, + :great_great_great_grandchild + ] + |> Enum.with_index() + |> Map.new() + + @type generation_name :: + :self + | :child + | :grandchild + | :great_grandchild + | :great_great_grandchild + | :great_great_great_grandchild + + @type module_spec :: module() | String.t() + @type module_name :: String.t() + @type generation_spec :: generation_name | non_neg_integer + @type generation_option :: {:from, generation_spec} | {:to, generation_spec} | {:to, :infinity} + @type generation_options :: [generation_option] + + # Public api + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + @doc """ + Collects struct modules in the given ranges + + When given your project, and a root module, this function returns a list of module names + that fall within the given collection range. Given a module's descendent tree, a + range can be specified in the following ways: + + `named:` A keyword list contiaining `:from` (optional, defaults to `:self`) and + `:to` (optional, defaults to `:self`) keys. The values of these keys can be either + a number representing the degree of the descendent generation (o for self, 1 + for child, etc) or named generations (`:self`, `:child`, `:grandchild`, etc). For example, + the collectionn range: `from: :child, to: :great_grandchild` will collect all struct + modules where the root module is thier parent up to and including all modules where the + root module is their great grandparent, and is equivalent to the range `1..2`, + Of course, if you want to return all the struct_modules, you can simply use `to: :infinity`. + + `range`: A `Range` struct containing the starting and ending generations. The module passed in + as `root_module` is generation 0, its child is generation 1, its grandchild is generation 2, + and so on. + """ + @spec collect_struct_modules(Project.t(), module_spec) :: [module_name] + @spec collect_struct_modules(Project.t(), module_spec, generation_options | Range.t()) :: [ + module_name + ] + def collect_struct_modules(project, root_module, opts \\ []) + + def collect_struct_modules(%Project{} = project, root_module, opts) when is_list(opts) do + collect_struct_modules(project, root_module, extract_range(opts)) + end + + def collect_struct_modules(%Project{} = project, root_module, :infinity) do + project + |> name() + |> GenServer.call({:collect_struct_modules, root_module, :infinity}) + end + + def collect_struct_modules(%Project{} = project, root_module, %Range{} = range) do + project + |> name() + |> GenServer.call({:collect_struct_modules, root_module, range}) + end + + @doc """ + Returns true if a module in the given generation range defines a struct + + see `collect_struct_modules/3` for an explanation of generation ranges + """ + + @spec defines_struct?(Project.t(), module_spec) :: boolean + @spec defines_struct?(Project.t(), module_spec, generation_options | Range.t()) :: boolean + def defines_struct?(project, root_module, opts \\ []) + + def defines_struct?(%Project{} = project, root_module, opts) when is_list(opts) do + defines_struct?(project, root_module, extract_range(opts)) + end + + def defines_struct?(%Project{} = project, root_module, %Range{} = range) do + project + |> name() + |> GenServer.call({:defines_struct?, root_module, range}) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([%Project{} = project]) do + Api.register_listener(project, self(), [ + project_index_ready(), + module_updated(), + struct_discovered() + ]) + + state = State.new(project) + {:ok, state} + end + + @impl GenServer + def handle_call({:defines_struct?, parent_module, %Range{} = range}, _from, %State{} = state) do + {:reply, State.descendent_defines_struct?(state, parent_module, range), state} + end + + @impl GenServer + def handle_call( + {:collect_struct_modules, parent_module, range_or_infinity}, + _from, + %State{} = state + ) do + {:reply, State.descendent_struct_modules(state, parent_module, range_or_infinity), state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name, struct: nil), %State{} = state) do + state = State.delete_struct_module(state, module_name) + {:noreply, state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name), %State{} = state) do + state = State.add_struct_module(state, module_name) + {:noreply, state} + end + + @impl GenServer + def handle_info(struct_discovered(module: module_name), %State{} = state) do + state = State.add_struct_module(state, module_name) + {:noreply, state} + end + + require Logger + + @impl GenServer + def handle_info(project_index_ready(), %State{} = state) do + {:ok, struct_definitions} = Api.struct_definitions(state.project) + + state = + Enum.reduce(struct_definitions, State.new(state.project), fn module, state -> + State.add_struct_module(state, module) + end) + + {:noreply, state} + end + + # Private + + def name(%Project{} = project) do + :"#{Project.name(project)}::intelligence" + end + + defp extract_range(to: :infinity) do + :infinity + end + + defp extract_range(opts) when is_list(opts) do + from = Keyword.get(opts, :from, :self) + from = Map.get(@generations, from, from) + + to = Keyword.get(opts, :to, :self) + to = Map.get(@generations, to, to) + + from..to + end +end diff --git a/expert/lib/lexical/server/project/node.ex b/expert/lib/lexical/server/project/node.ex new file mode 100644 index 00000000..50825a85 --- /dev/null +++ b/expert/lib/lexical/server/project/node.ex @@ -0,0 +1,108 @@ +defmodule Expert.Project.Node do + @moduledoc """ + A genserver responsibile for starting the remote node and cleaning up the build directory if it crashes + """ + + defmodule State do + defstruct [:project, :node, :supervisor_pid] + + def new(project, node, supervisor_pid) do + %__MODULE__{project: project, node: node, supervisor_pid: supervisor_pid} + end + end + + alias Forge.Project + alias Engine + alias Expert.Project.Progress + + require Logger + + use GenServer + use Progress.Support + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, project, name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::node" + end + + def node_name(%Project{} = project) do + project + |> name() + |> GenServer.call(:node_name) + end + + def trigger_build(%Project{} = project) do + project + |> name() + |> GenServer.cast(:trigger_build) + end + + @impl GenServer + def init(%Project{} = project) do + case with_progress(project, "Project Node", fn -> start_node(project) end) do + {:ok, state} -> + {:ok, state, {:continue, :trigger_build}} + + error -> + {:stop, error} + end + end + + @impl GenServer + def handle_continue(:trigger_build, %State{} = state) do + Engine.Api.schedule_compile(state.project, true) + {:noreply, state} + end + + @impl true + def handle_call(:node_name, _from, %State{} = state) do + {:reply, state.node, state} + end + + @impl GenServer + def handle_cast(:trigger_build, %State{} = state) do + Engine.Api.schedule_compile(state.project, true) + {:noreply, state} + end + + @impl GenServer + def handle_info({:nodedown, _}, %State{} = state) do + Logger.warning("The node has died. Restarting after deleting the build directory") + + with :ok <- delete_build_artifacts(state.project), + {:ok, new_state} <- start_node(state.project) do + {:noreply, new_state} + else + error -> + {:stop, error, state} + end + end + + # private api + + def start_node(%Project{} = project) do + with {:ok, node, node_pid} <- Engine.start_link(project) do + Node.monitor(node, true) + {:ok, State.new(project, node, node_pid)} + end + end + + defp delete_build_artifacts(%Project{} = project) do + build_path = Engine.Build.path(project) + + case File.rm_rf(build_path) do + {:ok, _deleted} -> :ok + error -> error + end + end +end diff --git a/expert/lib/lexical/server/project/progress.ex b/expert/lib/lexical/server/project/progress.ex new file mode 100644 index 00000000..5ec91eb8 --- /dev/null +++ b/expert/lib/lexical/server/project/progress.ex @@ -0,0 +1,46 @@ +defmodule Expert.Project.Progress do + alias Forge.Project + alias Expert.Project.Progress.State + + import Forge.Api.Messages + + use GenServer + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([project]) do + {:ok, State.new(project)} + end + + @impl true + def handle_info(project_progress(stage: stage) = message, %State{} = state) do + new_state = apply(State, stage, [state, message]) + {:noreply, new_state} + end + + def handle_info(percent_progress(stage: stage) = message, %State{} = state) do + new_state = apply(State, stage, [state, message]) + + {:noreply, new_state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::progress" + end + + def whereis(%Project{} = project) do + project |> name() |> Process.whereis() + end +end diff --git a/expert/lib/lexical/server/project/progress/percentage.ex b/expert/lib/lexical/server/project/progress/percentage.ex new file mode 100644 index 00000000..f17ae430 --- /dev/null +++ b/expert/lib/lexical/server/project/progress/percentage.ex @@ -0,0 +1,67 @@ +defmodule Expert.Project.Progress.Percentage do + @moduledoc """ + The backing data structure for percentage based progress reports + """ + alias Lexical.Math + alias Lexical.Protocol.Notifications + alias Lexical.Protocol.Types.WorkDone + + @enforce_keys [:token, :kind, :max] + defstruct [:token, :kind, :title, :message, :max, current: 0] + + def begin(title, max) do + token = System.unique_integer([:positive]) + %__MODULE__{token: token, kind: :begin, title: title, max: max} + end + + def report(percentage, delta, message \\ "") + + def report(%__MODULE__{} = percentage, delta, message) when is_integer(delta) and delta >= 0 do + new_current = percentage.current + delta + + %__MODULE__{percentage | kind: :report, message: message, current: new_current} + end + + def report(%__MODULE__{} = percentage, delta, _message) when is_integer(delta) do + percentage + end + + def report(_, _, _) do + nil + end + + def complete(%__MODULE__{} = percentage, message) do + %__MODULE__{percentage | kind: :end, current: percentage.max, message: message} + end + + def to_protocol(%__MODULE__{kind: :begin} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Begin.new(kind: "begin", title: value.title, percentage: 0) + ) + end + + def to_protocol(%__MODULE__{kind: :report} = value) do + percent_complete = + (value.current / value.max * 100) + |> round() + |> Math.clamp(0, 100) + + Notifications.Progress.new( + token: value.token, + value: + WorkDone.Progress.Report.new( + kind: "report", + message: value.message, + percentage: percent_complete + ) + ) + end + + def to_protocol(%__MODULE__{kind: :end} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.End.new(kind: "end", message: value.message) + ) + end +end diff --git a/expert/lib/lexical/server/project/progress/state.ex b/expert/lib/lexical/server/project/progress/state.ex new file mode 100644 index 00000000..82c87ec8 --- /dev/null +++ b/expert/lib/lexical/server/project/progress/state.ex @@ -0,0 +1,106 @@ +defmodule Expert.Project.Progress.State do + alias Forge.Project + alias Lexical.Protocol.Id + alias Lexical.Protocol.Requests + alias Expert.Configuration + alias Expert.Project.Progress.Percentage + alias Expert.Project.Progress.Value + alias Expert.Transport + + import Forge.Api.Messages + + defstruct project: nil, progress_by_label: %{} + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def begin(%__MODULE__{} = state, project_progress(label: label)) do + progress = Value.begin(label) + progress_by_label = Map.put(state.progress_by_label, label, progress) + + write_work_done(progress.token) + write(progress) + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def begin(%__MODULE__{} = state, percent_progress(label: label, max: max)) do + progress = Percentage.begin(label, max) + progress_by_label = Map.put(state.progress_by_label, label, progress) + write_work_done(progress.token) + write(progress) + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def report(%__MODULE__{} = state, project_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn old_value -> + new_value = Value.report(old_value, message) + {new_value, new_value} + end) + + write(progress) + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def report( + %__MODULE__{} = state, + percent_progress(label: label, message: message, delta: delta) + ) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn old_percentage -> + new_percentage = Percentage.report(old_percentage, delta, message) + {new_percentage, new_percentage} + end) + + write(progress) + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def complete(%__MODULE__{} = state, project_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end) + + case progress do + %Value{} = progress -> + progress |> Value.complete(message) |> write + + _ -> + :ok + end + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def complete(%__MODULE__{} = state, percent_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end) + + case progress do + %Percentage{} = progress -> + progress |> Percentage.complete(message) |> write() + + nil -> + :ok + end + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + defp write_work_done(token) do + if Configuration.client_supports?(:work_done_progress) do + progress = Requests.CreateWorkDoneProgress.new(id: Id.next(), token: token) + Transport.write(progress) + end + end + + defp write(%progress_module{token: token} = progress) when not is_nil(token) do + if Configuration.client_supports?(:work_done_progress) do + progress |> progress_module.to_protocol() |> Transport.write() + end + end + + defp write(_), do: :ok +end diff --git a/expert/lib/lexical/server/project/progress/support.ex b/expert/lib/lexical/server/project/progress/support.ex new file mode 100644 index 00000000..29f11a65 --- /dev/null +++ b/expert/lib/lexical/server/project/progress/support.ex @@ -0,0 +1,42 @@ +defmodule Expert.Project.Progress.Support do + alias Forge.Project + alias Expert.Project.Progress + + import Forge.Api.Messages + + defmacro __using__(_) do + quote do + import unquote(__MODULE__), only: [with_progress: 3] + end + end + + def with_progress(project, label, func) when is_function(func, 0) do + dest = Progress.name(project) + + try do + send(dest, project_progress(label: label, stage: :begin)) + func.() + after + send(dest, project_progress(label: label, stage: :complete)) + end + end + + def with_percentage_progress(%Project{} = project, label, max, func) + when is_function(func, 1) do + dest = Progress.name(project) + + report_progress = fn delta, message -> + message = + percent_progress(label: label, max: max, message: message, delta: delta, stage: :report) + + send(dest, message) + end + + try do + send(dest, percent_progress(label: label, max: max, stage: :begin)) + func.(report_progress) + after + send(dest, percent_progress(label: label, stage: :complete)) + end + end +end diff --git a/expert/lib/lexical/server/project/progress/value.ex b/expert/lib/lexical/server/project/progress/value.ex new file mode 100644 index 00000000..2bc2fdee --- /dev/null +++ b/expert/lib/lexical/server/project/progress/value.ex @@ -0,0 +1,45 @@ +defmodule Expert.Project.Progress.Value do + alias Lexical.Protocol.Notifications + alias Lexical.Protocol.Types.WorkDone + + @enforce_keys [:token, :kind] + defstruct [:token, :kind, :title, :message] + + def begin(title) do + token = System.unique_integer([:positive]) + %__MODULE__{token: token, kind: :begin, title: title} + end + + def report(%__MODULE__{token: token}, message) do + %__MODULE__{token: token, kind: :report, message: message} + end + + def report(_, _) do + nil + end + + def complete(%__MODULE__{token: token}, message) do + %__MODULE__{token: token, kind: :end, message: message} + end + + def to_protocol(%__MODULE__{kind: :begin} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Begin.new(kind: "begin", title: value.title) + ) + end + + def to_protocol(%__MODULE__{kind: :report} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Report.new(kind: "report", message: value.message) + ) + end + + def to_protocol(%__MODULE__{kind: :end} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.End.new(kind: "end", message: value.message) + ) + end +end diff --git a/expert/lib/lexical/server/project/search_listener.ex b/expert/lib/lexical/server/project/search_listener.ex new file mode 100644 index 00000000..7b006384 --- /dev/null +++ b/expert/lib/lexical/server/project/search_listener.ex @@ -0,0 +1,55 @@ +defmodule Expert.Project.SearchListener do + alias Lexical.Formats + alias Forge.Project + alias Lexical.Protocol.Id + alias Lexical.Protocol.Requests + alias Expert.Api + alias Expert + alias Expert.Window + + import Forge.Api.Messages + + use GenServer + require Logger + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + defp name(%Project{} = project) do + :"#{Project.name(project)}::search_listener" + end + + @impl GenServer + def init([%Project{} = project]) do + Api.register_listener(project, self(), [ + project_reindex_requested(), + project_reindexed() + ]) + + {:ok, project} + end + + @impl GenServer + def handle_info(project_reindex_requested(), %Project{} = project) do + Logger.info("project reindex requested") + send_code_lens_refresh() + + {:noreply, project} + end + + def handle_info(project_reindexed(elapsed_ms: elapsed), %Project{} = project) do + message = "Reindexed #{Project.name(project)} in #{Formats.time(elapsed, unit: :millisecond)}" + Logger.info(message) + send_code_lens_refresh() + + Window.show_info_message(message) + + {:noreply, project} + end + + defp send_code_lens_refresh do + request = Requests.CodeLensRefresh.new(id: Id.next()) + Server.server_request(request) + end +end diff --git a/expert/lib/lexical/server/project/supervisor.ex b/expert/lib/lexical/server/project/supervisor.ex new file mode 100644 index 00000000..6490c0f9 --- /dev/null +++ b/expert/lib/lexical/server/project/supervisor.ex @@ -0,0 +1,53 @@ +defmodule Expert.Project.Supervisor do + alias Forge.Project + alias Engine.ProjectNodeSupervisor + alias Expert.Project.Diagnostics + alias Expert.Project.Intelligence + alias Expert.Project.Node + alias Expert.Project.Progress + alias Expert.Project.SearchListener + + use Supervisor + + def dynamic_supervisor_name do + Expert.ProjectSupervisor + end + + def options do + [name: dynamic_supervisor_name(), strategy: :one_for_one] + end + + def start_link(%Project{} = project) do + Supervisor.start_link(__MODULE__, project, name: supervisor_name(project)) + end + + def init(%Project{} = project) do + children = [ + {Progress, project}, + {ProjectNodeSupervisor, project}, + {Node, project}, + {Diagnostics, project}, + {Intelligence, project}, + {SearchListener, project} + ] + + Supervisor.init(children, strategy: :one_for_one) + end + + def start(%Project{} = project) do + DynamicSupervisor.start_child(dynamic_supervisor_name(), {__MODULE__, project}) + end + + def stop(%Project{} = project) do + pid = + project + |> supervisor_name() + |> Process.whereis() + + DynamicSupervisor.terminate_child(dynamic_supervisor_name(), pid) + end + + defp supervisor_name(%Project{} = project) do + :"#{Project.name(project)}::supervisor" + end +end diff --git a/expert/lib/lexical/server/provider/handlers/code_action.ex b/expert/lib/lexical/server/provider/handlers/code_action.ex new file mode 100644 index 00000000..5b56b067 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/code_action.ex @@ -0,0 +1,39 @@ +defmodule Expert.Provider.Handlers.CodeAction do + alias GenLSP.Requests.TextDocumentCodeAction + alias GenLSP.Structures.Diagnostic + alias GenLSP.Structures.WorkspaceEdit + alias Forge.CodeAction + alias Expert.Configuration + + require Logger + + def handle(%TextDocumentCodeAction{} = request, %Configuration{} = config) do + diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1) + + code_actions = + Engine.Api.code_actions( + config.project, + request.document, + request.range, + diagnostics, + request.context.only || :all + ) + + results = Enum.map(code_actions, &to_result/1) + reply = Responses.CodeAction.new(request.id, results) + + {:reply, reply} + end + + defp to_code_action_diagnostic(%Diagnostic{} = diagnostic) do + CodeAction.Diagnostic.new(diagnostic.range, diagnostic.message, diagnostic.source) + end + + defp to_result(%CodeAction{} = action) do + Types.CodeAction.new( + title: action.title, + kind: action.kind, + edit: Workspace.Edit.new(changes: %{action.uri => action.changes}) + ) + end +end diff --git a/expert/lib/lexical/server/provider/handlers/code_lens.ex b/expert/lib/lexical/server/provider/handlers/code_lens.ex new file mode 100644 index 00000000..c6114951 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/code_lens.ex @@ -0,0 +1,58 @@ +defmodule Expert.Provider.Handlers.CodeLens do + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Project + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.CodeLens + alias Engine + alias Expert.Configuration + alias Expert.Provider.Handlers + + import Document.Line + require Logger + + def handle(%Requests.CodeLens{} = request, %Configuration{} = config) do + lenses = + case reindex_lens(config.project, request.document) do + nil -> [] + lens -> List.wrap(lens) + end + + response = Responses.CodeLens.new(request.id, lenses) + {:reply, response} + end + + defp reindex_lens(%Project{} = project, %Document{} = document) do + if show_reindex_lens?(project, document) do + range = def_project_range(document) + command = Handlers.Commands.reindex_command(project) + + CodeLens.new(command: command, range: range) + end + end + + @project_regex ~r/def\s+project\s/ + defp def_project_range(%Document{} = document) do + # returns the line in mix.exs where `def project` occurs + Enum.reduce_while(document.lines, nil, fn + line(text: line_text, line_number: line_number), _ -> + if String.match?(line_text, @project_regex) do + start_pos = Position.new(document, line_number, 1) + end_pos = Position.new(document, line_number, String.length(line_text)) + range = Range.new(start_pos, end_pos) + {:halt, range} + else + {:cont, nil} + end + end) + end + + defp show_reindex_lens?(%Project{} = project, %Document{} = document) do + document_path = Path.expand(document.path) + + document_path == Project.mix_exs_path(project) and + not Engine.Api.index_running?(project) + end +end diff --git a/expert/lib/lexical/server/provider/handlers/commands.ex b/expert/lib/lexical/server/provider/handlers/commands.ex new file mode 100644 index 00000000..6e21f2e5 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/commands.ex @@ -0,0 +1,57 @@ +# defmodule Expert.Provider.Handlers.Commands do +# alias Forge.Project +# alias Expert.Configuration +# alias Expert.Window +# +# require Logger +# +# @reindex_name "Reindex" +# +# def names do +# [@reindex_name] +# end +# +# def reindex_command(%Project{} = project) do +# project_name = Project.name(project) +# +# %GenLSP.Structures.Command{ +# title: "Rebuild #{project_name}'s code search index", +# command: @reindex_name +# } +# end +# +# # def handle( +# # %GenLSP.Requests.WorkspaceExecuteCommand{params: params} = request, +# # %Configuration{} = config +# # ) do +# # response = +# # case params.command do +# # @reindex_name -> +# # Logger.info("Reindex #{Project.name(config.project)}") +# # reindex(config.project, request.id) +# # +# # invalid -> +# # message = "#{invalid} is not a valid command" +# # internal_error(request.id, message) +# # end +# # +# # {:reply, response} +# # end +# +# # defp reindex(%Project{} = project, request_id) do +# # case Engine.Api.reindex(project) do +# # :ok -> +# # Responses.ExecuteCommand.new(request_id, "ok") +# # +# # error -> +# # Window.show_error_message("Indexing #{Project.name(project)} failed") +# # Logger.error("Indexing command failed due to #{inspect(error)}") +# # +# # internal_error(request_id, "Could not reindex: #{error}") +# # end +# # end +# # +# # defp internal_error(request_id, message) do +# # Responses.ExecuteCommand.error(request_id, :internal_error, message) +# # end +# end diff --git a/expert/lib/lexical/server/provider/handlers/completion.ex b/expert/lib/lexical/server/provider/handlers/completion.ex new file mode 100644 index 00000000..634ba4ca --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/completion.ex @@ -0,0 +1,36 @@ +defmodule Expert.Provider.Handlers.Completion do + alias Lexical.Ast + alias Forge.Document + alias Forge.Document.Position + alias GenLSP.Structures.CompletionContext + alias Expert.CodeIntelligence + alias Expert.Configuration + + require Logger + + def handle(%Requests.Completion{} = request, %Configuration{} = config) do + completions = + CodeIntelligence.Completion.complete( + config.project, + document_analysis(request.document, request.position), + request.position, + request.context || + %CompletionContext{trigger_kind: GenLSP.Enumerations.CompletionTriggerKind.invoked()} + ) + + response = Responses.Completion.new(request.id, completions) + {:reply, response} + end + + defp document_analysis(%Document{} = document, %Position{} = position) do + case Document.Store.fetch(document.uri, :analysis) do + {:ok, %Document{}, %Ast.Analysis{} = analysis} -> + Ast.reanalyze_to(analysis, position) + + _ -> + document + |> Ast.analyze() + |> Ast.reanalyze_to(position) + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/document_symbols.ex b/expert/lib/lexical/server/provider/handlers/document_symbols.ex new file mode 100644 index 00000000..af0946db --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/document_symbols.ex @@ -0,0 +1,52 @@ +defmodule Expert.Provider.Handlers.DocumentSymbols do + alias Forge.Document + alias GenLSP.Requests.TextDocumentDocumentSymbol + alias Engine.Api + # alias Forge.CodeIntelligence.Symbols + alias Expert.Configuration + alias GenLSP.Structures.DocumentSymbol + + def handle(%TextDocumentDocumentSymbol{} = request, %Configuration{} = config) do + symbols = + config.project + |> Api.document_symbols(request.document) + |> Enum.map(&to_response(&1, request.document)) + + {:reply, symbols} + end + + def to_response(%DocumentSymbol{} = root, %Document{} = document) do + children = + case root.children do + list when is_list(list) -> + Enum.map(list, &to_response(&1, document)) + + _ -> + nil + end + + %DocumentSymbol{ + children: children, + detail: root.detail, + kind: to_kind(root.type), + name: root.name, + range: root.range, + selection_range: root.detail_range + } + end + + defp to_kind(:struct), do: :struct + defp to_kind(:module), do: :module + defp to_kind(:variable), do: :variable + defp to_kind({:function, _}), do: :function + defp to_kind({:protocol, _}), do: :module + defp to_kind(:module_attribute), do: :constant + defp to_kind(:ex_unit_test), do: :method + defp to_kind(:ex_unit_describe), do: :method + defp to_kind(:ex_unit_setup), do: :method + defp to_kind(:ex_unit_setup_all), do: :method + defp to_kind(:type), do: :type_parameter + defp to_kind(:spec), do: :interface + defp to_kind(:file), do: :file + defp to_kind(_), do: :string +end diff --git a/expert/lib/lexical/server/provider/handlers/find_references.ex b/expert/lib/lexical/server/provider/handlers/find_references.ex new file mode 100644 index 00000000..d030e6c7 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/find_references.ex @@ -0,0 +1,26 @@ +defmodule Expert.Provider.Handlers.FindReferences do + alias Lexical.Ast + alias Forge.Document + alias Lexical.Protocol.Requests.FindReferences + alias Lexical.Protocol.Responses + alias Engine.Api + alias Expert.Configuration + + require Logger + + def handle(%FindReferences{} = request, %Configuration{} = config) do + include_declaration? = !!request.context.include_declaration + + locations = + case Document.Store.fetch(request.document.uri, :analysis) do + {:ok, _document, %Ast.Analysis{} = analysis} -> + Api.references(config.project, analysis, request.position, include_declaration?) + + _ -> + nil + end + + response = Responses.FindReferences.new(request.id, locations) + {:reply, response} + end +end diff --git a/expert/lib/lexical/server/provider/handlers/formatting.ex b/expert/lib/lexical/server/provider/handlers/formatting.ex new file mode 100644 index 00000000..03710679 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/formatting.ex @@ -0,0 +1,24 @@ +defmodule Expert.Provider.Handlers.Formatting do + alias Forge.Document.Changes + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Engine + alias Expert.Configuration + + require Logger + + def handle(%Requests.Formatting{} = request, %Configuration{} = config) do + document = request.document + + case Engine.Api.format(config.project, document) do + {:ok, %Changes{} = document_edits} -> + response = Responses.Formatting.new(request.id, document_edits) + Logger.info("Response #{inspect(response)}") + {:reply, response} + + {:error, reason} -> + Logger.error("Formatter failed #{inspect(reason)}") + {:reply, Responses.Formatting.new(request.id, nil)} + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/go_to_definition.ex b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex new file mode 100644 index 00000000..b90cb67d --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex @@ -0,0 +1,19 @@ +defmodule Expert.Provider.Handlers.GoToDefinition do + alias Lexical.Protocol.Requests.GoToDefinition + alias Lexical.Protocol.Responses + alias Engine + alias Expert.Configuration + + require Logger + + def handle(%GoToDefinition{} = request, %Configuration{} = config) do + case Engine.Api.definition(config.project, request.document, request.position) do + {:ok, native_location} -> + {:reply, Responses.GoToDefinition.new(request.id, native_location)} + + {:error, reason} -> + Logger.error("GoToDefinition failed: #{inspect(reason)}") + {:reply, Responses.GoToDefinition.new(request.id, nil)} + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/hover.ex b/expert/lib/lexical/server/provider/handlers/hover.ex new file mode 100644 index 00000000..b72851a0 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/hover.ex @@ -0,0 +1,237 @@ +defmodule Expert.Provider.Handlers.Hover do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Forge.Document + alias Forge.Document.Position + alias Forge.Project + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Hover + alias Engine + alias Forge.CodeIntelligence.Docs + alias Expert.Configuration + alias Expert.Provider.Markdown + + require Logger + + def handle(%Requests.Hover{} = request, %Configuration{} = config) do + maybe_hover = + with {:ok, _document, %Ast.Analysis{} = analysis} <- + Document.Store.fetch(request.document.uri, :analysis), + {:ok, entity, range} <- resolve_entity(config.project, analysis, request.position), + {:ok, markdown} <- hover_content(entity, config.project) do + content = Markdown.to_content(markdown) + %Hover{contents: content, range: range} + else + error -> + Logger.warning("Could not resolve hover request, got: #{inspect(error)}") + nil + end + + {:reply, Responses.Hover.new(request.id, maybe_hover)} + end + + defp resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + Engine.Api.resolve_entity(project, analysis, position) + end + + defp hover_content({kind, module}, %Project{} = project) when kind in [:module, :struct] do + case Engine.Api.docs(project, module, exclude_hidden: false) do + {:ok, %Docs{} = module_docs} -> + header = module_header(kind, module_docs) + types = module_header_types(kind, module_docs) + + additional_sections = [ + module_doc(module_docs.doc), + module_footer(kind, module_docs) + ] + + if Enum.all?([types | additional_sections], &empty?/1) do + {:error, :no_doc} + else + header_block = "#{header}\n\n#{types}" |> String.trim() |> Markdown.code_block() + {:ok, Markdown.join_sections([header_block | additional_sections])} + end + + _ -> + {:error, :no_doc} + end + end + + defp hover_content({:call, module, fun, arity}, %Project{} = project) do + with {:ok, %Docs{} = module_docs} <- Engine.Api.docs(project, module), + {:ok, entries} <- Map.fetch(module_docs.functions_and_macros, fun) do + sections = + entries + |> Enum.sort_by(& &1.arity) + |> Enum.filter(&(&1.arity >= arity)) + |> Enum.map(&entry_content/1) + + {:ok, Markdown.join_sections(sections, Markdown.separator())} + end + end + + defp hover_content({:type, module, type, arity}, %Project{} = project) do + with {:ok, %Docs{} = module_docs} <- Engine.Api.docs(project, module), + {:ok, entries} <- Map.fetch(module_docs.types, type) do + case Enum.find(entries, &(&1.arity == arity)) do + %Docs.Entry{} = entry -> + {:ok, entry_content(entry)} + + _ -> + {:error, :no_type} + end + end + end + + defp hover_content(type, _) do + {:error, {:unsupported, type}} + end + + defp module_header(:module, %Docs{module: module}) do + Ast.Module.name(module) + end + + defp module_header(:struct, %Docs{module: module}) do + "%#{Ast.Module.name(module)}{}" + end + + defp module_header_types(:module, %Docs{}), do: "" + + defp module_header_types(:struct, %Docs{} = docs) do + docs.types + |> Map.get(:t, []) + |> sort_entries() + |> Enum.flat_map(& &1.defs) + |> Enum.join("\n\n") + end + + defp module_doc(s) when is_binary(s), do: s + defp module_doc(_), do: nil + + defp module_footer(:module, docs) do + callbacks = format_callbacks(docs.callbacks) + + unless empty?(callbacks) do + Markdown.section(callbacks, header: "Callbacks") + end + end + + defp module_footer(:struct, _docs), do: nil + + defp entry_content(%Docs.Entry{kind: fn_or_macro} = entry) + when fn_or_macro in [:function, :macro] do + call_header = call_header(entry) + specs = Enum.map_join(entry.defs, "\n", &("@spec " <> &1)) + + header = + [call_header, specs] + |> Markdown.join_sections() + |> String.trim() + |> Markdown.code_block() + + Markdown.join_sections([header, entry_doc_content(entry.doc)]) + end + + defp entry_content(%Docs.Entry{kind: :type} = entry) do + header = + Markdown.code_block(""" + #{call_header(entry)} + + #{type_defs(entry)}\ + """) + + Markdown.join_sections([header, entry_doc_content(entry.doc)]) + end + + @one_line_header_cutoff 50 + + defp call_header(%Docs.Entry{kind: :type} = entry) do + module_name = Ast.Module.name(entry.module) + + one_line_header = "#{module_name}.#{entry.name}/#{entry.arity}" + + two_line_header = + "#{last_module_name(module_name)}.#{entry.name}/#{entry.arity}\n#{module_name}" + + if String.length(one_line_header) >= @one_line_header_cutoff do + two_line_header + else + one_line_header + end + end + + defp call_header(%Docs.Entry{kind: maybe_macro} = entry) do + [signature | _] = entry.signature + module_name = Ast.Module.name(entry.module) + + macro_prefix = + if maybe_macro == :macro do + "(macro) " + else + "" + end + + one_line_header = "#{macro_prefix}#{module_name}.#{signature}" + + two_line_header = + "#{macro_prefix}#{last_module_name(module_name)}.#{signature}\n#{module_name}" + + if String.length(one_line_header) >= @one_line_header_cutoff do + two_line_header + else + one_line_header + end + end + + defp last_module_name(module_name) do + module_name + |> String.split(".") + |> List.last() + end + + defp type_defs(%Docs.Entry{metadata: %{opaque: true}} = entry) do + Enum.map_join(entry.defs, "\n", fn def -> + def + |> String.split("::", parts: 2) + |> List.first() + |> String.trim() + end) + end + + defp type_defs(%Docs.Entry{} = entry) do + Enum.join(entry.defs, "\n") + end + + defp format_callbacks(callbacks) do + callbacks + |> Map.values() + |> List.flatten() + |> sort_entries() + |> Enum.map_join("\n", fn %Docs.Entry{} = entry -> + header = + entry.defs + |> Enum.map_join("\n", &("@callback " <> &1)) + |> Markdown.code_block() + + if is_binary(entry.doc) do + """ + #{header} + #{entry_doc_content(entry.doc)} + """ + else + header + end + end) + end + + defp entry_doc_content(s) when is_binary(s), do: String.trim(s) + defp entry_doc_content(_), do: nil + + defp sort_entries(entries) do + Enum.sort_by(entries, &{&1.name, &1.arity}) + end + + defp empty?(empty) when empty in [nil, "", []], do: true + defp empty?(_), do: false +end diff --git a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex new file mode 100644 index 00000000..4f52664b --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex @@ -0,0 +1,55 @@ +defmodule Expert.Provider.Handlers.WorkspaceSymbol do + alias Lexical.Protocol.Requests.WorkspaceSymbol + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Location + alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind + alias Lexical.Protocol.Types.Workspace.Symbol + alias Engine.Api + alias Forge.CodeIntelligence.Symbols + alias Expert.Configuration + + require Logger + + def handle(%WorkspaceSymbol{} = request, %Configuration{} = config) do + symbols = + if String.length(request.query) > 1 do + config.project + |> Api.workspace_symbols(request.query) + |> tap(fn symbols -> Logger.info("syms #{inspect(Enum.take(symbols, 5))}") end) + |> Enum.map(&to_response/1) + else + [] + end + + response = Responses.WorkspaceSymbol.new(request.id, symbols) + {:reply, response} + end + + def to_response(%Symbols.Workspace{} = root) do + Symbol.new( + kind: to_kind(root.type), + location: to_location(root.link), + name: root.name, + container_name: root.container_name + ) + end + + defp to_location(%Symbols.Workspace.Link{} = link) do + Location.new(uri: link.uri, range: link.detail_range) + end + + defp to_kind(:struct), do: :struct + defp to_kind(:module), do: :module + defp to_kind({:protocol, _}), do: :module + defp to_kind({:lx_protocol, _}), do: :module + defp to_kind(:variable), do: :variable + defp to_kind({:function, _}), do: :function + defp to_kind(:module_attribute), do: :constant + defp to_kind(:ex_unit_test), do: :method + defp to_kind(:ex_unit_describe), do: :method + defp to_kind(:ex_unit_setup), do: :method + defp to_kind(:ex_unit_setup_all), do: :method + defp to_kind(:type), do: :type_parameter + defp to_kind(:spec), do: :interface + defp to_kind(:file), do: :file +end diff --git a/expert/lib/lexical/server/provider/markdown.ex b/expert/lib/lexical/server/provider/markdown.ex new file mode 100644 index 00000000..0257d738 --- /dev/null +++ b/expert/lib/lexical/server/provider/markdown.ex @@ -0,0 +1,83 @@ +defmodule Expert.Provider.Markdown do + @moduledoc """ + Utilities for formatting Markdown content. + """ + + alias GenLSP.Structures.MarkupContent + @type markdown :: String.t() + + @doc """ + Converts a string of Markdown into LSP markup content. + """ + @spec to_content(markdown) :: Markup.Content.t() + def to_content(markdown) when is_binary(markdown) do + %MarkupContent{kind: GenLSP.Enumerations.MarkupKind.markdown(), value: markdown} + end + + @doc """ + Wraps the content inside a Markdown code block. + + ## Options + + * `:lang` - The language for the block. Defaults to `"elixir"`. + + """ + @spec code_block(String.t(), [opt]) :: markdown + when opt: {:lang, String.t()} + def code_block(content, opts \\ []) do + lang = Keyword.get(opts, :lang, "elixir") + + """ + ```#{lang} + #{content} + ``` + """ + end + + @doc """ + Creates a Markdown section with a header. + + ## Options + + * `:header` (required) - The section title. + * `:header_level` - Defaults to `2`. + + """ + @spec section(markdown, [opt]) :: markdown + when opt: {:header, markdown} | {:header_level, pos_integer()} + def section(content, opts) do + header = Keyword.fetch!(opts, :header) + header_level = Keyword.get(opts, :header_level, 2) + + """ + #{String.duplicate("#", header_level)} #{header} + + #{content} + """ + end + + @doc """ + Joins multiple Markdown sections. + """ + @spec join_sections([markdown | nil]) :: markdown + def join_sections(sections, joiner \\ "\n\n") when is_list(sections) do + with_rules = + sections + |> Stream.filter(&(is_binary(&1) and &1 != "")) + |> Stream.map(&String.trim(&1)) + |> Enum.intersperse(joiner) + + case with_rules do + [] -> "" + _ -> IO.iodata_to_binary([with_rules, "\n"]) + end + end + + @doc """ + Returns a string that can be used to join sections with a horizontal rule. + """ + @spec separator() :: markdown + def separator do + "\n\n---\n\n" + end +end diff --git a/expert/lib/lexical/server/state.ex b/expert/lib/lexical/server/state.ex new file mode 100644 index 00000000..20b7ce46 --- /dev/null +++ b/expert/lib/lexical/server/state.ex @@ -0,0 +1,286 @@ +defmodule Expert.State do + alias Forge.Document + alias Expert.CodeIntelligence + alias Expert.Configuration + alias Expert.Project + # alias Expert.Provider.Handlers + alias GenLSP.Requests.Initialize + + require Logger + + import Forge.Api.Messages + + defstruct configuration: nil, + initialized?: false, + shutdown_received?: false, + in_flight_requests: %{} + + @supported_code_actions [ + :quick_fix, + :source_organize_imports + ] + + def new do + %__MODULE__{} + end + + def initialize(%__MODULE__{initialized?: false} = state, %Initialize{params: params}) do + client_name = + case params.client_info do + %{name: name} -> name + _ -> nil + end + + config = Configuration.new(params.root_uri, params.capabilities, client_name) + new_state = %__MODULE__{state | configuration: config, initialized?: true} + Logger.info("Starting project at uri #{config.project.root_uri}") + + # we do this in the server process + # event.id + # |> initialize_result() + # |> Transport.write() + + # same here + # Transport.write(registrations()) + + Project.Supervisor.start(config.project) + {:ok, new_state} + end + + def initialize(%__MODULE__{initialized?: true}, %Initialize{}) do + {:error, :already_initialized} + end + + def in_flight?(%__MODULE__{} = state, request_id) do + Map.has_key?(state.in_flight_requests, request_id) + end + + def add_request(%__MODULE__{} = state, request, callback) do + Transport.write(request) + + in_flight_requests = Map.put(state.in_flight_requests, request.id, {request, callback}) + + %__MODULE__{state | in_flight_requests: in_flight_requests} + end + + def finish_request(%__MODULE__{} = state, response) do + %{"id" => response_id} = response + + case Map.pop(state.in_flight_requests, response_id) do + {{%request_module{} = request, callback}, in_flight_requests} -> + case request_module.parse_response(response) do + {:ok, response} -> + callback.(request, {:ok, response.result}) + + error -> + Logger.info("failed to parse response for #{request_module}, #{inspect(error)}") + callback.(request, error) + end + + %__MODULE__{state | in_flight_requests: in_flight_requests} + + _ -> + state + end + end + + def default_configuration(%__MODULE__{configuration: config}) do + Configuration.default(config) + end + + def apply(%__MODULE__{initialized?: false}, request) do + Logger.error("Received #{request.method} before server was initialized") + {:error, :not_initialized} + end + + def apply(%__MODULE__{shutdown_received?: true} = state, %Exit{}) do + Logger.warning("Received an Exit notification. Halting the server in 150ms") + :timer.apply_after(50, System, :halt, [0]) + {:ok, state} + end + + def apply(%__MODULE__{shutdown_received?: true}, request) do + Logger.error("Received #{request.method} after shutdown. Ignoring") + {:error, :shutting_down} + end + + def apply(%__MODULE__{} = state, %DidChangeConfiguration{} = event) do + case Configuration.on_change(state.configuration, event) do + {:ok, config} -> + {:ok, %__MODULE__{state | configuration: config}} + + {:ok, config, response} -> + Transport.write(response) + {:ok, %__MODULE__{state | configuration: config}} + end + + {:ok, state} + end + + def apply(%__MODULE__{} = state, %DidChange{lsp: event}) do + uri = event.text_document.uri + version = event.text_document.version + project = state.configuration.project + + case Document.Store.get_and_update( + uri, + &Document.apply_content_changes(&1, version, event.content_changes) + ) do + {:ok, updated_source} -> + updated_message = + file_changed( + uri: updated_source.uri, + open?: true, + from_version: version, + to_version: updated_source.version + ) + + Api.broadcast(project, updated_message) + Api.compile_document(state.configuration.project, updated_source) + {:ok, state} + + error -> + error + end + end + + def apply(%__MODULE__{} = state, %DidOpen{} = did_open) do + %TextDocument.Item{ + text: text, + uri: uri, + version: version, + language_id: language_id + } = did_open.lsp.text_document + + case Document.Store.open(uri, text, version, language_id) do + :ok -> + Logger.info("opened #{uri}") + {:ok, state} + + error -> + Logger.error("Could not open #{uri} #{inspect(error)}") + error + end + end + + def apply(%__MODULE__{} = state, %DidClose{lsp: event}) do + uri = event.text_document.uri + + case Document.Store.close(uri) do + :ok -> + {:ok, state} + + error -> + Logger.warning( + "Received textDocument/didClose for a file that wasn't open. URI was #{uri}" + ) + + error + end + end + + def apply(%__MODULE__{} = state, %DidSave{lsp: event}) do + uri = event.text_document.uri + + case Document.Store.save(uri) do + :ok -> + Api.schedule_compile(state.configuration.project, false) + {:ok, state} + + error -> + Logger.error("Save failed for uri #{uri} error was #{inspect(error)}") + error + end + end + + def apply(%__MODULE__{} = state, %Initialized{}) do + Logger.info("Lexical Initialized") + {:ok, %__MODULE__{state | initialized?: true}} + end + + def apply(%__MODULE__{} = state, %Shutdown{} = shutdown) do + Transport.write(Responses.Shutdown.new(id: shutdown.id)) + Logger.error("Shutting down") + + {:ok, %__MODULE__{state | shutdown_received?: true}} + end + + def apply(%__MODULE__{} = state, %Notifications.DidChangeWatchedFiles{lsp: event}) do + project = state.configuration.project + + Enum.each(event.changes, fn %FileEvent{} = change -> + event = filesystem_event(project: Project, uri: change.uri, event_type: change.type) + Engine.Api.broadcast(project, event) + end) + + {:ok, state} + end + + def apply(%__MODULE__{} = state, msg) do + Logger.error("Ignoring unhandled message: #{inspect(msg)}") + {:ok, state} + end + + defp registrations do + RegisterCapability.new(id: Id.next(), registrations: [file_watcher_registration()]) + end + + @did_changed_watched_files_id "-42" + @watched_extensions ~w(ex exs) + defp file_watcher_registration do + extension_glob = "{" <> Enum.join(@watched_extensions, ",") <> "}" + + watchers = [ + FileSystemWatcher.new(glob_pattern: "**/mix.lock"), + FileSystemWatcher.new(glob_pattern: "**/*.#{extension_glob}") + ] + + Registration.new( + id: @did_changed_watched_files_id, + method: "workspace/didChangeWatchedFiles", + register_options: DidChangeWatchedFiles.Registration.Options.new(watchers: watchers) + ) + end + + def initialize_result(event_id) do + sync_options = + TextDocument.Sync.Options.new(open_close: true, change: :incremental, save: true) + + code_action_options = + CodeAction.Options.new(code_action_kinds: @supported_code_actions, resolve_provider: false) + + code_lens_options = CodeLens.Options.new(resolve_provider: false) + + command_options = ExecuteCommand.Registration.Options.new(commands: Handlers.Commands.names()) + + completion_options = + Completion.Options.new(trigger_characters: CodeIntelligence.Completion.trigger_characters()) + + server_capabilities = + Types.ServerCapabilities.new( + code_action_provider: code_action_options, + code_lens_provider: code_lens_options, + completion_provider: completion_options, + definition_provider: true, + document_formatting_provider: true, + document_symbol_provider: true, + execute_command_provider: command_options, + hover_provider: true, + references_provider: true, + text_document_sync: sync_options, + workspace_symbol_provider: true + ) + + result = + Types.Initialize.Result.new( + capabilities: server_capabilities, + server_info: + Types.Initialize.Result.ServerInfo.new( + name: "Lexical", + version: "0.0.1" + ) + ) + + Responses.InitializeResult.new(event_id, result) + end +end diff --git a/expert/lib/lexical/server/task_queue.ex b/expert/lib/lexical/server/task_queue.ex new file mode 100644 index 00000000..bebcbd73 --- /dev/null +++ b/expert/lib/lexical/server/task_queue.ex @@ -0,0 +1,218 @@ +defmodule Expert.TaskQueue do + defmodule State do + alias Lexical.Proto.Convert + alias Lexical.Proto.LspTypes.ResponseError + alias Expert.Transport + import Lexical.Logging + require Logger + + defstruct ids_to_tasks: %{}, pids_to_ids: %{} + + @type t :: %__MODULE__{} + + def new do + %__MODULE__{} + end + + def task_supervisor_name do + __MODULE__.TaskSupervisor + end + + @spec add(t, request_id :: term(), mfa :: {module(), atom(), [term()]}) :: t + def add(%__MODULE__{} = state, request_id, {_, _, _} = mfa) do + task = %Task{} = as_task(request_id, mfa) + + %__MODULE__{ + state + | ids_to_tasks: Map.put(state.ids_to_tasks, request_id, task), + pids_to_ids: Map.put(state.pids_to_ids, task.pid, request_id) + } + end + + @spec cancel(t, request_id :: term()) :: t + def cancel(%__MODULE__{} = state, request_id) do + with {:ok, %Task{} = task} <- Map.fetch(state.ids_to_tasks, request_id), + :ok <- cancel_task(task) do + write_error(request_id, "Request cancelled", :request_cancelled) + + %__MODULE__{ + state + | ids_to_tasks: Map.delete(state.ids_to_tasks, request_id), + pids_to_ids: Map.delete(state.pids_to_ids, task.pid) + } + else + _ -> + state + end + end + + def size(%__MODULE__{} = state) do + map_size(state.ids_to_tasks) + end + + def task_finished(%__MODULE__{} = state, pid, reason) do + case Map.pop(state.pids_to_ids, pid) do + {nil, _} -> + state + + {request_id, new_pids_to_ids} -> + log_task_run_time(state.ids_to_tasks[request_id], :success) + maybe_log_task(reason, request_id) + + %__MODULE__{ + state + | pids_to_ids: new_pids_to_ids, + ids_to_tasks: Map.delete(state.ids_to_tasks, request_id) + } + end + end + + defp maybe_log_task(:normal, _), + do: :ok + + defp maybe_log_task(reason, request_id), + do: Logger.warning("Request id #{request_id} failed with reason #{inspect(reason)}") + + defp as_task(request_id, {m, f, a}) do + handler = fn -> + try do + case apply(m, f, a) do + :noreply -> + {:request_complete, request_id} + + {:reply, reply} -> + write_reply(reply) + + {:request_complete, request_id} + end + rescue + e -> + exception_string = Exception.format(:error, e, __STACKTRACE__) + Logger.error(exception_string) + write_error(request_id, exception_string) + + {:request_complete, request_id} + end + end + + run_task(handler, {m, f, a}) + end + + defp write_reply(response) do + case timed_log("convert", fn -> Convert.to_lsp(response) end) do + {:ok, lsp_response} -> + Transport.write(lsp_response) + + error -> + error_message = """ + Failed to convert #{response.__struct__}: + + #{inspect(error, pretty: true)}\ + """ + + Logger.critical(""" + #{error_message} + + #{inspect(response, pretty: true)}\ + """) + + write_error(response.id, error_message) + end + end + + defp write_error(id, message, code \\ :internal_error) do + error = ResponseError.new(code: code, message: message) + + Transport.write(%{id: id, error: error}) + end + + defp run_task(fun, mfa) when is_function(fun) do + task_supervisor_name() + |> Task.Supervisor.async_nolink(fun) + |> Map.merge(%{started_at: System.system_time(:microsecond), mfa: mfa}) + end + + defp cancel_task(%Task{} = task) do + log_task_run_time(task, :canceled) + Process.exit(task.pid, :canceled) + :ok + end + + defp log_task_run_time(%Task{} = task, result) do + case task do + %{started_at: ts, mfa: {m, f, a}} -> + elapsed = System.system_time(:microsecond) - ts + + Logger.warning( + "Task #{m}.#{f}/#{length(a)} ran for #{Lexical.Formats.time(elapsed)}. Result #{inspect(result)}" + ) + + _ -> + :ok + end + end + end + + use GenServer + + def task_supervisor_name do + State.task_supervisor_name() + end + + @spec add(request_id :: term(), mfa :: {module(), atom(), [term()]}) :: :ok + def add(request_id, {_, _, _} = mfa) do + GenServer.call(__MODULE__, {:add, request_id, mfa}) + end + + @spec size() :: non_neg_integer() + def size do + GenServer.call(__MODULE__, :size) + end + + def cancel(%{lsp: %{id: id}}) do + cancel(id) + end + + def cancel(%{id: request_id}) do + cancel(request_id) + end + + def cancel(request_id) do + GenServer.call(__MODULE__, {:cancel, request_id}) + end + + # genserver callbacks + + def start_link(_) do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, State.new()} + end + + def handle_call({:add, request_id, mfa}, _from, %State{} = state) do + new_state = State.add(state, request_id, mfa) + {:reply, :ok, new_state} + end + + def handle_call({:cancel, request_id}, _from, %State{} = state) do + new_state = State.cancel(state, request_id) + {:reply, :ok, new_state} + end + + def handle_call(:size, _from, %State{} = state) do + {:reply, State.size(state), state} + end + + def handle_info({:DOWN, _ref, :process, pid, reason}, state) do + new_state = State.task_finished(state, pid, reason) + {:noreply, new_state} + end + + def handle_info({ref, {:request_complete, _request_id}}, %State{} = state) + when is_reference(ref) do + # This head handles the replies from the tasks, which we don't really care about. + {:noreply, state} + end +end diff --git a/expert/mix.exs b/expert/mix.exs index feeb947a..bd24ce74 100644 --- a/expert/mix.exs +++ b/expert/mix.exs @@ -50,6 +50,7 @@ defmodule Expert.MixProject do github: "elixir-tools/gen_lsp", branch: "change-schematic-function", override: true}, # {:gen_lsp, "~> 0.10"}, {:burrito, "~> 1.0", only: [:dev, :prod]}, + {:forge, path: "../forge"}, {:namespace, path: "../namespace"} ] end diff --git a/expert/mix.lock b/expert/mix.lock index ceab83ed..502bca55 100644 --- a/expert/mix.lock +++ b/expert/mix.lock @@ -1,5 +1,6 @@ %{ "burrito": {:hex, :burrito, "1.2.0", "88f973469edcb96bd984498fb639d3fc4dbf01b52baab072b40229f03a396789", [:mix], [{:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:req, ">= 0.4.0", [hex: :req, repo: "hexpm", optional: false]}, {:typed_struct, "~> 0.2.0 or ~> 0.3.0", [hex: :typed_struct, repo: "hexpm", optional: false]}], "hexpm", "7e22158023c6558de615795ab135d27f0cbd9a0602834e3e474fe41b448afba9"}, + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "706c498be371882366151b588e5cd13c9c08404c", []}, "finch": {:hex, :finch, "0.19.0", "c644641491ea854fc5c1bbaef36bfc764e3f08e7185e1f084e35e0672241b76d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "fc5324ce209125d1e2fa0fcd2634601c52a787aff1cd33ee833664a5af4ea2b6"}, "gen_lsp": {:git, "https://github.com/elixir-tools/gen_lsp.git", "f63f284289ef61b678ab6bd2cbcf3a6ba3d9fcdd", [branch: "change-schematic-function"]}, "hpax": {:hex, :hpax, "1.0.0", "28dcf54509fe2152a3d040e4e3df5b265dcb6cb532029ecbacf4ce52caea3fd2", [:mix], [], "hexpm", "7f1314731d711e2ca5fdc7fd361296593fc2542570b3105595bb0bc6d0fad601"}, @@ -10,6 +11,8 @@ "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"}, "req": {:hex, :req, "0.5.6", "8fe1eead4a085510fe3d51ad854ca8f20a622aae46e97b302f499dfb84f726ac", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cfaa8e720945d46654853de39d368f40362c2641c4b2153c886418914b372185"}, "schematic": {:hex, :schematic, "0.2.1", "0b091df94146fd15a0a343d1bd179a6c5a58562527746dadd09477311698dbb1", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0b255d65921e38006138201cd4263fd8bb807d9dfc511074615cd264a571b3b1"}, + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, "typed_struct": {:hex, :typed_struct, "0.3.0", "939789e3c1dca39d7170c87f729127469d1315dcf99fee8e152bb774b17e7ff7", [:mix], [], "hexpm", "c50bd5c3a61fe4e198a8504f939be3d3c85903b382bde4865579bc23111d1b6d"}, } diff --git a/forge/.formatter.exs b/forge/.formatter.exs new file mode 100644 index 00000000..c3ee8ab8 --- /dev/null +++ b/forge/.formatter.exs @@ -0,0 +1,26 @@ +eventual_assertions = [ + assert_eventually: 1, + assert_eventually: 2, + refute_eventually: 1, + refute_eventually: 2 +] + +detected_assertions = [ + assert_detected: 1, + assert_detected: 2, + refute_detected: 1, + refute_detected: 2 +] + +assertions = eventual_assertions ++ detected_assertions + +[ + inputs: [ + "{mix,.formatter}.exs", + "{config,test}/**/*.{ex,exs}", + "lib/lexical/**/*.{ex,ex}", + "lib/mix/**/*.{ex,exs}" + ], + locals_without_parens: assertions, + export: [locals_without_parens: assertions] +] diff --git a/forge/.gitignore b/forge/.gitignore new file mode 100644 index 00000000..848aea9f --- /dev/null +++ b/forge/.gitignore @@ -0,0 +1,26 @@ +# The directory Mix will write compiled artifacts to. +/_build/ + +# If you run "mix test --cover", coverage assets end up here. +/cover/ + +# The directory Mix downloads your dependencies sources to. +/deps/ + +# Where third-party dependencies like ExDoc output generated docs. +/doc/ + +# Ignore .fetch files in case you like to edit your project deps locally. +/.fetch + +# If the VM crashes, it generates a dump, let's ignore it too. +erl_crash.dump + +# Also ignore archive artifacts (built via "mix archive.build"). +*.ez + +# Ignore package tarball (built via "mix hex.build"). +forge-*.tar + +# Temporary files, for example, from tests. +/tmp/ diff --git a/forge/README.md b/forge/README.md new file mode 100644 index 00000000..371ea44d --- /dev/null +++ b/forge/README.md @@ -0,0 +1,21 @@ +# Forge + +**TODO: Add description** + +## Installation + +If [available in Hex](https://hex.pm/docs/publish), the package can be installed +by adding `forge` to your list of dependencies in `mix.exs`: + +```elixir +def deps do + [ + {:forge, "~> 0.1.0"} + ] +end +``` + +Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc) +and published on [HexDocs](https://hexdocs.pm). Once published, the docs can +be found at . + diff --git a/forge/lib/elixir/features.ex b/forge/lib/elixir/features.ex new file mode 100644 index 00000000..790bfb74 --- /dev/null +++ b/forge/lib/elixir/features.ex @@ -0,0 +1,42 @@ +defmodule Elixir.Features do + alias Forge.VM.Versions + + def with_diagnostics? do + function_exported?(Code, :with_diagnostics, 1) + end + + def compile_keeps_current_directory? do + Version.match?(System.version(), ">= 1.15.0") + end + + def after_verify? do + Version.match?(System.version(), ">= 1.14.0") + end + + def details_in_context? do + Version.match?(System.version(), ">= 1.16.0") + end + + def span_in_diagnostic? do + Version.match?(System.version(), ">= 1.16.0") + end + + def contains_set_theoretic_types? do + Version.match?(System.version(), ">= 1.17.0") + end + + @doc """ + Whether the `:compressed` ETS table option can be safely used. + + A bug in Erlang/OTP 27.0.0 and 27.0.1 can cause a segfault when + traversing the entire table with something like `:ets.foldl/3` if the + `:compressed` table option is used. The issue was fixed in Erlang 27.1 + + Relevant issue: https://github.com/erlang/otp/issues/8682 + """ + def can_use_compressed_ets_table? do + %{erlang: erlang_version} = Versions.to_versions(Versions.current()) + + Version.match?(erlang_version, "< 27.0.0 or >= 27.1.0") + end +end diff --git a/forge/lib/forge.ex b/forge/lib/forge.ex new file mode 100644 index 00000000..48baf075 --- /dev/null +++ b/forge/lib/forge.ex @@ -0,0 +1,21 @@ +defmodule Forge do + @typedoc "A string representation of a uri" + @type uri :: String.t() + + @typedoc "A string representation of a path on the filesystem" + @type path :: String.t() + + alias Forge.Project + + def project_node? do + !!:persistent_term.get({__MODULE__, :project}, false) + end + + def get_project do + :persistent_term.get({__MODULE__, :project}, nil) + end + + def set_project(%Project{} = project) do + :persistent_term.put({__MODULE__, :project}, project) + end +end diff --git a/forge/lib/forge/analyzer.ex b/forge/lib/forge/analyzer.ex new file mode 100644 index 00000000..4fd2ec14 --- /dev/null +++ b/forge/lib/forge/analyzer.ex @@ -0,0 +1,213 @@ +defmodule Forge.Analyzer do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Use + alias Forge.Document.Position + alias Forge.Analyzer.Aliases + alias Forge.Analyzer.Imports + alias Forge.Analyzer.Requires + alias Forge.Analyzer.Uses + + require Logger + + defdelegate aliases_at(analysis, position), to: Aliases, as: :at + defdelegate imports_at(analysis, position), to: Imports, as: :at + + @spec requires_at(Analysis.t(), Position.t()) :: [module()] + def requires_at(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Requires.at(position) + |> Enum.reduce([], fn %Require{} = require, acc -> + case expand_alias(require.module, analysis, position) do + {:ok, expanded} -> [expanded | acc] + _ -> [Module.concat(require.as) | acc] + end + end) + end + + @spec uses_at(Analysis.t(), Position.t()) :: [module()] + def uses_at(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Uses.at(position) + |> Enum.reduce([], fn %Use{} = use, acc -> + case expand_alias(use.module, analysis, position) do + {:ok, expanded} -> [expanded | acc] + _ -> [Module.concat(use.module) | acc] + end + end) + end + + def resolve_local_call(%Analysis{} = analysis, %Position{} = position, function_name, arity) do + maybe_imported_mfa = + analysis + |> imports_at(position) + |> Enum.find(fn + {_, ^function_name, ^arity} -> true + _ -> false + end) + + if is_nil(maybe_imported_mfa) do + aliases = aliases_at(analysis, position) + current_module = aliases[:__MODULE__] + {current_module, function_name, arity} + else + maybe_imported_mfa + end + end + + @doc """ + Expands an alias at the given position in the context of a document + analysis. + + When we refer to a module, it's usually a short name, often aliased or + in a nested module. This function finds the full name of the module at + a cursor position. + + For example, if we have: + + defmodule Project do + defmodule Issue do + defstruct [:message] + end + + def message(%Issue{|} = issue) do # cursor marked as `|` + end + end + + We could get the expansion for the `Issue` alias at the cursor position + like so: + + iex> Analyzer.expand_alias([:Issue], analysis, position) + {:ok, Project.Issue} + + Another example: + + defmodule Project do + defmodule Issue do + defstruct [:message] + end + end + + defmodule MyModule do + alias Project, as: MyProject + + def message(%MyProject.Issue{|} = issue) do + end + end + + This would yield the same result: + + iex> Analyzer.expand_alias([:MyProject, :Issue], analysis, position) + {:ok, Project.Issue} + + If no aliases are present at the given position, no expansion occurs: + + iex> Analyzer.expand_alias([:Some, :Other, :Module], analysis, position) + {:ok, Some.Other.Module} + + """ + @spec expand_alias( + Ast.alias_segments() | module(), + Analysis.t(), + Position.t() | {Position.line(), Position.character()} + ) :: + {:ok, module()} | :error + def expand_alias([_ | _] = segments, %Analysis{} = analysis, %Position{} = position) do + with %Analysis{valid?: true} = analysis <- Forge.Ast.reanalyze_to(analysis, position), + aliases <- aliases_at(analysis, position), + {:ok, resolved} <- resolve_alias(segments, aliases) do + {:ok, Module.concat(resolved)} + else + _ -> + case segments do + [:__MODULE__] -> + # we've had a request for the current module, but none was found + # so we've failed. This can happen if we're resolving the current + # module in a script, or inside the defmodule call. + :error + + _ -> + if Enum.all?(segments, &is_atom/1) do + {:ok, Module.concat(segments)} + else + :error + end + end + end + end + + def expand_alias(module, %Analysis{} = analysis, %Position{} = position) + when is_atom(module) and not is_nil(module) do + {:elixir, segments} = Ast.Module.safe_split(module, as: :atoms) + expand_alias(segments, analysis, position) + end + + def expand_alias(empty, _, _) when empty in [nil, []] do + Logger.warning("nothing to expand (expand_alias was passed #{inspect(empty)})") + :error + end + + @doc """ + Returns the current module at the given position in the analysis + """ + def current_module(%Analysis{} = analysis, %Position{} = position) do + expand_alias([:__MODULE__], analysis, position) + end + + defp resolve_alias([{:@, _, [{:protocol, _, _}]} | rest], alias_mapping) do + with {:ok, protocol} <- Map.fetch(alias_mapping, :"@protocol") do + Ast.reify_alias(protocol, rest) + end + end + + defp resolve_alias( + [{:__aliases__, _, [{:@, _, [{:protocol, _, _}]} | _] = protocol}], + alias_mapping + ) do + resolve_alias(protocol, alias_mapping) + end + + defp resolve_alias([{:@, _, [{:for, _, _} | _]} | rest], alias_mapping) do + with {:ok, protocol_for} <- Map.fetch(alias_mapping, :"@for") do + Ast.reify_alias(protocol_for, rest) + end + end + + defp resolve_alias( + [{:__aliases__, _, [{:@, _, [{:for, _, _}]} | _] = protocol_for}], + alias_mapping + ) do + resolve_alias(protocol_for, alias_mapping) + end + + defp resolve_alias([first | _] = segments, aliases_mapping) when is_tuple(first) do + with {:ok, current_module} <- Map.fetch(aliases_mapping, :__MODULE__) do + Ast.reify_alias(current_module, segments) + end + end + + defp resolve_alias([first | _] = segments, aliases_mapping) when is_atom(first) do + with :error <- fetch_leading_alias(segments, aliases_mapping) do + fetch_trailing_alias(segments, aliases_mapping) + end + end + + defp resolve_alias(_, _), do: :error + + defp fetch_leading_alias([first | rest], aliases_mapping) do + with {:ok, resolved} <- Map.fetch(aliases_mapping, first) do + {:ok, [resolved | rest]} + end + end + + defp fetch_trailing_alias(segments, aliases_mapping) do + # Trailing aliases happen when you use the curly syntax to define multiple aliases + # in one go, like Foo.{First, Second.Third, Fourth} + # Our alias mapping will have Third mapped to Foo.Second.Third, so we need to look + # for Third, wheras the leading alias will look for Second in the mappings. + with {:ok, resolved} <- Map.fetch(aliases_mapping, List.last(segments)) do + {:ok, List.wrap(resolved)} + end + end +end diff --git a/forge/lib/forge/analyzer/aliases.ex b/forge/lib/forge/analyzer/aliases.ex new file mode 100644 index 00000000..fbd1fe5f --- /dev/null +++ b/forge/lib/forge/analyzer/aliases.ex @@ -0,0 +1,62 @@ +defmodule Forge.Analyzer.Aliases do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position + + @spec at(Analysis.t(), Position.t()) :: %{atom() => module()} + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + scope + |> Scope.alias_map(position) + |> Map.new(fn {as, %Alias{} = alias} -> + {as, Alias.to_module(alias)} + end) + + [] -> + %{} + end + end + + @doc """ + Resolves an alias in the context of a line and a scope + (used internally when calculating imports) + """ + def resolve_at(%Scope{} = scope, module, line) do + aliases = Scope.alias_map(scope, line) + + case module do + # unquote(__MODULE__).SubModule + [{:unquote, _, [{:__MODULE__, _, _}]} | suffix] -> + resolve_current_module(aliases, suffix) + + [{:__MODULE__, _, _} | suffix] -> + resolve_current_module(aliases, suffix) + + [prefix | suffix] -> + case aliases do + %{^prefix => _} -> + current_module = resolve_alias(aliases, prefix, suffix) + + Module.concat([current_module | suffix]) + + _ -> + Module.concat(module) + end + end + end + + defp resolve_current_module(aliases, suffix) do + resolve_alias(aliases, :__MODULE__, suffix) + end + + defp resolve_alias(aliases, prefix, suffix) do + current_module = + aliases + |> Map.get(prefix) + |> Alias.to_module() + + Module.concat([current_module | suffix]) + end +end diff --git a/forge/lib/forge/analyzer/imports.ex b/forge/lib/forge/analyzer/imports.ex new file mode 100644 index 00000000..c0ab6959 --- /dev/null +++ b/forge/lib/forge/analyzer/imports.ex @@ -0,0 +1,144 @@ +defmodule Forge.Analyzer.Imports do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.ProcessCache + alias Forge.Analyzer.Aliases + alias Forge.Module.Loader + + @spec at(Analysis.t(), Position.t()) :: [Scope.import_mfa()] + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + imports(scope, position) + + _ -> + [] + end + end + + @spec imports(Scope.t(), Scope.scope_position()) :: [Scope.import_mfa()] + def imports(%Scope{} = scope, position \\ :end) do + scope + |> import_map(position) + |> Map.values() + |> List.flatten() + end + + defp import_map(%Scope{} = scope, position) do + end_line = Scope.end_line(scope, position) + + (kernel_imports(scope) ++ scope.imports) + # sorting by line ensures that imports on later lines + # override imports on earlier lines + |> Enum.sort_by(& &1.range.start.line) + |> Enum.take_while(&(&1.range.start.line <= end_line)) + |> Enum.reduce(%{}, fn %Import{} = import, current_imports -> + apply_to_scope(import, scope, current_imports) + end) + end + + defp apply_to_scope(%Import{} = import, current_scope, %{} = current_imports) do + import_module = Aliases.resolve_at(current_scope, import.module, import.range.start.line) + + functions = mfas_for(import_module, :functions) + macros = mfas_for(import_module, :macros) + + case import.selector do + :all -> + Map.put(current_imports, import_module, functions ++ macros) + + [only: :functions] -> + Map.put(current_imports, import_module, functions) + + [only: :macros] -> + Map.put(current_imports, import_module, macros) + + [only: :sigils] -> + sigils = mfas_for(import_module, :sigils) + Map.put(current_imports, import_module, sigils) + + [only: functions_to_import] -> + functions_to_import = function_and_arity_to_mfa(import_module, functions_to_import) + Map.put(current_imports, import_module, functions_to_import) + + [except: functions_to_except] -> + # This one is a little tricky. Imports using except have two cases. + # In the first case, if the module hasn't been previously imported, we + # collect all the functions in the current module and remove the ones in the + # except clause. + # If the module has been previously imported, we just remove the functions from + # the except clause from those that have been previously imported. + # See: https://hexdocs.pm/elixir/1.13.0/Kernel.SpecialForms.html#import/2-selector + + functions_to_except = function_and_arity_to_mfa(import_module, functions_to_except) + + if already_imported?(current_imports, import_module) do + Map.update!(current_imports, import_module, fn old_imports -> + old_imports -- functions_to_except + end) + else + to_import = (functions ++ macros) -- functions_to_except + Map.put(current_imports, import_module, to_import) + end + end + end + + defp already_imported?(%{} = current_imports, imported_module) do + case current_imports do + %{^imported_module => [_ | _]} -> true + _ -> false + end + end + + defp function_and_arity_to_mfa(current_module, fa_list) when is_list(fa_list) do + Enum.map(fa_list, fn {function, arity} -> {current_module, function, arity} end) + end + + defp mfas_for(current_module, type) do + if Loader.ensure_loaded?(current_module) do + fa_list = function_and_arities_for_module(current_module, type) + + function_and_arity_to_mfa(current_module, fa_list) + else + [] + end + end + + defp function_and_arities_for_module(module, :sigils) do + ProcessCache.trans({module, :info, :sigils}, fn -> + for {name, arity} <- module.__info__(:functions), + string_name = Atom.to_string(name), + sigil?(string_name, arity) do + {name, arity} + end + end) + end + + defp function_and_arities_for_module(module, type) do + ProcessCache.trans({module, :info, type}, fn -> + type + |> module.__info__() + |> Enum.reject(fn {name, arity} -> + string_name = Atom.to_string(name) + String.starts_with?(string_name, "_") or sigil?(string_name, arity) + end) + end) + end + + defp sigil?(string_name, arity) do + String.starts_with?(string_name, "sigil_") and arity in [1, 2] + end + + defp kernel_imports(%Scope{} = scope) do + start_pos = scope.range.start + range = Range.new(start_pos, start_pos) + + [ + Import.implicit(range, [:Kernel]), + Import.implicit(range, [:Kernel, :SpecialForms]) + ] + end +end diff --git a/forge/lib/forge/analyzer/requires.ex b/forge/lib/forge/analyzer/requires.ex new file mode 100644 index 00000000..45e0d555 --- /dev/null +++ b/forge/lib/forge/analyzer/requires.ex @@ -0,0 +1,26 @@ +defmodule Forge.Analyzer.Requires do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position + + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + scope.requires + |> Enum.filter(fn %Require{} = require -> + require_end = require.range.end + + if require_end.line == position.line do + require_end.character <= position.character + else + require_end.line < position.line + end + end) + |> Enum.uniq_by(& &1.as) + + _ -> + [] + end + end +end diff --git a/forge/lib/forge/analyzer/uses.ex b/forge/lib/forge/analyzer/uses.ex new file mode 100644 index 00000000..98cd68aa --- /dev/null +++ b/forge/lib/forge/analyzer/uses.ex @@ -0,0 +1,23 @@ +defmodule Forge.Analyzer.Uses do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position + + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + Enum.filter(scope.uses, fn use -> + use_end = use.range.end + + if position.line == use_end.line do + position.character >= use_end.character + else + position.line > use_end.line + end + end) + + _ -> + [] + end + end +end diff --git a/forge/lib/forge/api/messages.ex b/forge/lib/forge/api/messages.ex new file mode 100644 index 00000000..eea276da --- /dev/null +++ b/forge/lib/forge/api/messages.ex @@ -0,0 +1,139 @@ +defmodule Forge.Api.Messages do + alias Forge.Project + + import Record + defrecord :project_compile_requested, project: nil, build_number: 0 + + defrecord :project_compiled, + project: nil, + build_number: 0, + status: :successful, + diagnostics: [], + elapsed_ms: 0 + + defrecord :filesystem_event, project: nil, uri: nil, event_type: nil + + defrecord :file_changed, uri: nil, from_version: nil, to_version: nil, open?: false + + defrecord :file_compile_requested, project: nil, build_number: 0, uri: nil + + defrecord :file_compiled, + project: nil, + build_number: 0, + uri: nil, + status: :successful, + diagnostics: [], + elapsed_ms: 0 + + defrecord :file_deleted, project: nil, uri: nil + + defrecord :module_updated, file: nil, name: nil, functions: [], macros: [], struct: nil + + defrecord :project_diagnostics, project: nil, build_number: 0, diagnostics: [] + + defrecord :file_diagnostics, project: nil, build_number: 0, uri: nil, diagnostics: [] + + defrecord :project_progress, label: nil, message: nil, stage: :report + + defrecord :percent_progress, label: nil, message: nil, stage: :report, max: 0, delta: 0 + + defrecord :struct_discovered, module: nil, fields: [] + + defrecord :project_index_ready, project: nil + + defrecord :project_reindex_requested, project: nil + + defrecord :project_reindexed, project: nil, elapsed_ms: 0, status: :success + + @type compile_status :: :successful | :error + @type name_and_arity :: {atom, non_neg_integer} + @type field_list :: Keyword.t() | [atom] + @type diagnostics :: [Mix.Task.Compiler.Diagnostic.t()] + @type maybe_version :: nil | non_neg_integer() + + @type project_compile_requested :: + record(:project_compile_requested, + project: Forge.Project.t(), + build_number: non_neg_integer() + ) + @type project_compiled :: + record(:project_compiled, + project: Forge.Project.t(), + build_number: non_neg_integer(), + status: compile_status, + elapsed_ms: non_neg_integer + ) + + @type filesystem_event :: + record(:filesystem_event, + project: Project.t(), + uri: Forge.uri(), + event_type: :created | :updated | :deleted + ) + + @type file_changed :: + record(:file_changed, + uri: Forge.uri(), + from_version: maybe_version, + to_version: maybe_version, + open?: boolean() + ) + + @type file_compile_requested :: + record(:file_compile_requested, + project: Forge.Project.t(), + build_number: non_neg_integer(), + uri: Forge.uri() + ) + + @type file_compiled :: + record(:file_compiled, + project: Forge.Project.t(), + build_number: non_neg_integer(), + uri: Forge.uri(), + status: compile_status, + elapsed_ms: non_neg_integer + ) + + @type module_updated :: + record(:module_updated, + name: module(), + functions: [name_and_arity], + macros: [name_and_arity], + struct: field_list + ) + + @type project_diagnostics :: + record(:project_diagnostics, + project: Forge.Project.t(), + diagnostics: diagnostics() + ) + + @type file_diagnostics :: + record(:file_diagnostics, + project: Forge.Project.t(), + uri: Forge.uri(), + diagnostics: diagnostics() + ) + + @type project_progress :: + record(:project_progress, + label: String.t(), + message: String.t() | integer(), + stage: :prepare | :begin | :report | :complete + ) + + @type struct_discovered :: record(:struct_discovered, module: module(), fields: field_list()) + + @type project_index_ready :: record(:project_index_ready, project: Forge.Project.t()) + + @type project_reindex_requested :: + record(:project_reindex_requested, project: Forge.Project.t()) + + @type project_reindexed :: + record(:project_reindexed, + project: Forge.Project.t(), + elapsed_ms: non_neg_integer(), + status: :success | {:error, term()} + ) +end diff --git a/forge/lib/forge/ast.ex b/forge/lib/forge/ast.ex new file mode 100644 index 00000000..7ba8ac8a --- /dev/null +++ b/forge/lib/forge/ast.ex @@ -0,0 +1,731 @@ +defmodule Forge.Ast do + @moduledoc """ + Utilities for analyzing Forge documents as syntax trees. + + ## Analysis + + The preferred way to use this module is by first passing a document to + `analyze/1`, which returns a `%Forge.Ast.Analysis{}` struct that + will have already parsed and analyzed a significant portion of the + document, thus reducing the cost of successive operations. + + An analysis looks at the entire AST, and thus may fail if the document + contains syntax errors that prevent parsing. To a partial analysis up + to a certain point (usually the cursor position), use `reanalyze_to/2`, + which analyzes the document up to the given position and can therefore + be used even if later parts of the document contain syntax errors. + + ## Differences from `Code` + + This module includes functions for parsing documents (`t:Forge.Document/0`) + and strings into AST's that can be used with the `Sourceror` API and + include some additional metadata. + + The structure of code parsed using this module will be slightly + different than using `Code` directly. The most notable difference is + that atoms will be wrapped in a `:__block__` node that contains + additional metadata. + + Consider these two semantically-equivalent lists, for instance: + + iex> list_with_kw_syntax = "[foo: :bar]" + iex> list_with_tuple_syntax = "[{:foo, :bar}]" + + By default, `Code.string_to_quoted/1` does not differentiate between them: + + iex> list_with_kw_syntax |> Code.string_to_quoted() + {:ok, [foo: :bar]} + + iex> list_with_tuple_syntax |> Code.string_to_quoted() + {:ok, [foo: :bar]} + + In contrast, `Forge.Ast.from/1` does: + + iex> list_with_kw_syntax |> Forge.Ast.from() + {:ok, + {:__block__, [closing: [line: 1, column: 11], line: 1, column: 1], + [ + [ + {{:__block__, [format: :keyword, line: 1, column: 2], [:foo]}, + {:__block__, [line: 1, column: 7], [:bar]}} + ] + ]}} + + iex> list_with_tuple_syntax |> Forge.Ast.from() + {:ok, + {:__block__, [closing: [line: 1, column: 14], line: 1, column: 1], + [ + [ + {:__block__, [closing: [line: 1, column: 13], line: 1, column: 2], + [ + {{:__block__, [line: 1, column: 3], [:foo]}, + {:__block__, [line: 1, column: 9], [:bar]}} + ]} + ] + ]}} + + """ + + alias Future.Code, as: Code + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + alias Sourceror.Zipper + + require Logger + require Sourceror + + @typedoc "Return value from `Code.Fragment.cursor_context/2`" + @type cursor_context :: any() + + @typedoc "Return value from `Code.Fragment.surround_context/3`" + @type surround_context :: any() + + @type parse_error :: + {location :: keyword(), String.t() | {String.t(), String.t()}, String.t()} + + @type patch :: %{ + optional(:preserve_indentation) => boolean(), + range: patch_range(), + change: patch_change() + } + + @type patch_range :: %{start: patch_position(), end: patch_position()} + @type patch_position :: [patch_line | patch_column] + @type patch_line :: {:line, non_neg_integer()} + @type patch_column :: {:column, non_neg_integer()} + @type patch_change :: String.t() | (String.t() -> String.t()) + + @type short_alias :: atom() + @type alias_segments :: [short_alias] + + @type comment_metadata :: %{ + line: pos_integer(), + column: pos_integer(), + previous_eol_count: non_neg_integer(), + next_eol_count: non_neg_integer() + } + + @type position :: Position.t() | {Position.line(), Position.character()} + + @doc """ + Analyzes a document. + """ + @spec analyze(Document.t()) :: Analysis.t() + def analyze(%Document{} = document) do + document + |> from() + |> Analysis.new(document) + end + + @doc """ + Reanalyzes a document up to `position` if `analysis` is not valid. + + This can be used to analyze a fragment of an analyzed document up to + the cursor position. If the given analysis is already valid, this + function returns in unchanged. + + Note that the analysis generated for this may give invalid or incomplete + results for positions after the fragment. + + ## Examples + + iex> analysis = Ast.analyze(invalid_document) + %Ast.Analysis{valid?: false} + + iex> Ast.reanalyze_to(analysis, cursor_position) + %Ast.Analysis{} # may be valid or invalid + + """ + @spec reanalyze_to(Analysis.t(), position) :: Analysis.t() + def reanalyze_to(%Analysis{valid?: false} = analysis, position) do + %Position{} = position = normalize_position(position, analysis.document) + + analysis.document + |> fragment(position) + |> Analysis.new(analysis.document) + end + + def reanalyze_to(%Analysis{valid?: true} = analysis, _position) do + analysis + end + + @doc """ + Returns an AST generated from a valid document or string. + """ + @spec from(Document.t() | Analysis.t() | String.t()) :: + {:ok, Macro.t(), comment_metadata()} | {:error, parse_error()} + def from(%Document{} = document) do + document + |> Document.to_string() + |> from() + end + + def from(%Analysis{valid?: true} = analysis) do + comments = + analysis.comments_by_line + |> Map.values() + |> Enum.sort_by(& &1.line) + + {:ok, analysis.ast, comments} + end + + def from(%Analysis{valid?: false, parse_error: error}), do: error + + def from(s) when is_binary(s) do + do_string_to_quoted(s) + end + + @doc """ + Returns an AST fragment from the start of the document to the given position. + """ + @spec fragment(Document.t(), position) :: {:ok, Macro.t()} | {:error, parse_error()} + def fragment(%Document{} = document, position) do + # https://github.com/elixir-lang/elixir/issues/12673#issuecomment-1592845875 + # Note: because of the above issue: Using `cursor_context` + `container_cursor_to_quoted` + # can't deal with some cases like: `alias Foo.Bar, as: AnotherBar`, + # so we need to add a new line to make sure we can get the parrent node of the cursor + %{line: line} = normalize_position(position, document) + added_new_line_position = Position.new(document, line + 1, 1) + fragment = Document.fragment(document, added_new_line_position) + + case do_container_cursor_to_quoted(fragment) do + {:ok, quoted} -> + {:ok, quoted} + + _error -> + # https://github.com/elixir-lang/elixir/issues/12673#issuecomment-1626932280 + # NOTE: Adding new line doesn't always work, + # so we need to try again without adding new line + document_fragment = Document.fragment(document, position) + do_container_cursor_to_quoted(document_fragment) + end + end + + @doc """ + Parses the given fragment into an AST. + """ + @spec fragment(String.t()) :: {:ok, Macro.t()} | {:error, parse_error()} + def fragment(s) when is_binary(s) do + do_container_cursor_to_quoted(s) + end + + @doc """ + Returns the cursor context of the document at a position. + """ + @spec cursor_context(Analysis.t() | Document.t(), position) :: + {:ok, cursor_context()} | {:error, :cursor_context} + def cursor_context(%Analysis{} = analysis, position) do + cursor_context(analysis.document, position) + end + + def cursor_context(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + + document + |> Document.fragment(position) + |> do_cursor_context() + end + + @doc """ + Returns the surround context of the document at a position. + """ + @spec surround_context(Analysis.t() | Document.t(), position) :: + {:ok, surround_context()} | {:error, :surround_context} + def surround_context(%Analysis{} = analysis, position) do + surround_context(analysis.document, position) + end + + def surround_context(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + + document + |> Document.to_string() + |> do_surround_context(position) + end + + @doc """ + Returns the path to the innermost node in the document at the given position. + + This function differs from `cursor_path/2` in that it expects a valid + AST and the returned path will not contain a `:__cursor__` node. + """ + @spec path_at(Analysis.t() | Document.t(), position) :: + {:ok, [Macro.t(), ...]} | {:error, :not_found | parse_error()} + def path_at(%struct{} = document_or_analysis, %Position{} = position) + when struct in [Document, Analysis] do + with {:ok, ast, _} <- from(document_or_analysis) do + path_at(ast, position) + end + end + + @spec path_at(Macro.t(), Position.t()) :: + {:ok, [Macro.t(), ...]} | {:error, :not_found} + def path_at(ast, %Position{} = position) do + path = innermost_path(ast, [], &contains_position?(&1, position)) + + case path do + nil -> {:error, :not_found} + path -> {:ok, path} + end + end + + @doc """ + Returns the path to the cursor in a fragment of the document from the + start to the given position. + + This function differs from `path_at/2` in that it operates on an AST + fragment as opposed to a full AST and the call never fails, though it + may return an empty list. + """ + @spec cursor_path(Analysis.t() | Document.t(), position) :: [Macro.t()] + def cursor_path(%Analysis{} = analysis, position) do + cursor_path(analysis.document, position) + end + + def cursor_path(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + document_fragment = Document.fragment(document, position) + + case do_container_cursor_to_quoted(document_fragment) do + {:ok, quoted} -> + quoted + |> Future.Macro.path(&match?({:__cursor__, _, _}, &1)) + |> List.wrap() + + _ -> + [] + end + end + + @doc """ + Returns a zipper for the document AST focused at the given position. + """ + @spec zipper_at(Document.t(), Position.t()) :: {:ok, Zipper.t()} | {:error, parse_error()} + def zipper_at(%Document{} = document, %Position{} = position) do + with {:ok, ast, _} <- from(document) do + zipper_at_position(ast, position) + end + end + + @doc """ + Returns whether the given AST contains a position. + """ + @spec contains_position?(Macro.t(), Position.t()) :: boolean() + def contains_position?(ast, %Position{} = position) do + case Sourceror.get_range(ast) do + %{start: start_pos, end: end_pos} -> + start_pos = {start_pos[:line], start_pos[:column]} + end_pos = {end_pos[:line], end_pos[:column]} + within?(position, start_pos, end_pos) + + nil -> + false + end + end + + @doc """ + Converts the document to a zipper and traverses the nodes on the given line. + + The given function must accept and return a (potentially modified) zipper. + To maintain an accumulator, use `traverse_line/4`. + """ + @spec traverse_line(Document.t(), Position.line(), (Zipper.t() -> Zipper.t())) :: + {:ok, Zipper.t()} | {:error, parse_error()} + def traverse_line(%Document{} = document, line_number, fun) when is_integer(line_number) do + range = one_line_range(document, line_number) + traverse_in(document, range, fun) + end + + @spec traverse_line( + Document.t(), + Position.line(), + acc, + (Zipper.t(), acc -> {Zipper.t(), acc}) + ) :: + {:ok, Zipper.t(), acc} | {:error, parse_error()} + when acc: any() + def traverse_line(%Document{} = document, line_number, acc, fun) when is_integer(line_number) do + range = one_line_range(document, line_number) + traverse_in(document, range, acc, fun) + end + + @doc """ + Converts AST patches to document edits. + + Returns `{:ok, edits}` if all patches are valid and `:error` otherwise. + """ + @spec patches_to_edits(Document.t(), [patch()]) :: {:ok, [Edit.t()]} | :error + def patches_to_edits(%Document{} = document, patches) do + maybe_edits = + Enum.reduce_while(patches, [], fn patch, edits -> + case patch_to_edit(document, patch) do + {:ok, edit} -> {:cont, [edit | edits]} + error -> {:halt, error} + end + end) + + case maybe_edits do + edits when is_list(edits) -> {:ok, Enum.reverse(edits)} + error -> error + end + end + + @doc """ + Converts a single AST patch to a document edit. + + Returns `{:ok, edit}` if valid and `:error` otherwise. + """ + @spec patch_to_edit(Document.t(), patch()) :: {:ok, Edit.t()} | :error + def patch_to_edit(%Document{} = document, %{} = patch) do + %{change: change, range: %{start: start_pos, end: end_pos}} = patch + + with {:ok, range} <- patch_to_range(document, start_pos, end_pos) do + {:ok, Edit.new(change, range)} + end + end + + # Expands aliases given the rules in the special form + # https://hexdocs.pm/elixir/1.13.4/Kernel.SpecialForms.html#__aliases__/1 + def reify_alias(current_module, [:"Elixir" | _] = reified) do + {:ok, [current_module | reified]} + end + + def reify_alias(current_module, [:__MODULE__ | rest]) do + {:ok, [current_module | rest]} + end + + def reify_alias(current_module, [atom | _rest] = reified) when is_atom(atom) do + {:ok, [current_module | reified]} + end + + def reify_alias(current_module, [unreified | rest]) do + env = %Macro.Env{module: current_module} + + case Macro.expand(unreified, env) do + module when is_atom(module) -> {:ok, [module | rest]} + _ -> :error + end + end + + def reify_alias(current_module, []) do + {:ok, List.wrap(current_module)} + end + + @doc """ + Walks a quoted expression with an accumulator, applying `fun` to each + var or pinned var. + + Returns a tuple where the first element is the potentially modified + expression and the second is the accumulator. + """ + # Adapted from `ExUnit.Assertions.collect_vars_from_pattern/1`, + # licensed under Apache License 2.0: + # https://github.com/elixir-lang/elixir/blob/1e914b04b46125b3b9b251b64ee04380e523afc4/lib/ex_unit/lib/ex_unit/assertions.ex#L657 + @spec prewalk_vars(Macro.t(), acc, (Macro.t(), acc -> {Macro.t(), acc})) :: {Macro.t(), acc} + when acc: term() + def prewalk_vars(ast, acc, fun) do + {ast, {acc, _}} = + Macro.prewalk(ast, {acc, false}, fn + # <> + # ^^^^^^^^^^^ + {:"::", meta, [left, right]}, {acc, _prev_pinned?} -> + {right, acc} = prewalk_vars_in_binary(right, acc, fun) + {{:"::", meta, [left, right]}, {acc, false}} + + # skip vars inside quote or @ + {skip, _, [_]} = node, {acc, _prev_pinned?} when skip in [:@, :quote] -> + {node, {acc, false}} + + # skip _ + {:_, _, context} = node, {acc, _prev_pinned?} when is_atom(context) -> + {node, {acc, false}} + + # ^pinned + # emit the pinned var and set prev_pinned? so the var isn't omitted + # immediately after + {:^, _, [{name, _, context}]} = pinned, {acc, _prev_pinned?} + when is_atom(name) and is_atom(context) -> + {pinned, acc} = fun.(pinned, acc) + {pinned, {acc, true}} + + # var + {name, _, context} = var, {acc, false} when is_atom(name) and is_atom(context) -> + {var, acc} = fun.(var, acc) + {var, {acc, false}} + + # skip everything else + node, {acc, _prev_pinned?} -> + {node, {acc, false}} + end) + + {ast, acc} + end + + defp prewalk_vars_in_binary(right, acc, fun) do + Macro.prewalk(right, acc, fn + {mode, mode_meta, [{name, _, context} = var]}, acc + when is_atom(mode) and is_atom(name) and is_atom(context) -> + {var, acc} = fun.(var, acc) + {{mode, mode_meta, [var]}, acc} + + node, acc -> + {node, acc} + end) + end + + @doc """ + Returns whether a var with `name` and `context` is in `vars`. + """ + def has_var?(vars, name, context) do + Enum.any?(vars, &match?({^name, _, ^context}, &1)) + end + + # private + + defp do_string_to_quoted(string) when is_binary(string) do + Code.string_to_quoted_with_comments(string, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + columns: true, + unescape: false + ) + end + + defp do_container_cursor_to_quoted(fragment) when is_binary(fragment) do + Code.Fragment.container_cursor_to_quoted(fragment, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + columns: true, + unescape: false + ) + end + + defp do_cursor_context(fragment) when is_binary(fragment) do + case Code.Fragment.cursor_context(fragment) do + :none -> {:error, :cursor_context} + context -> {:ok, context} + end + end + + defp do_surround_context(fragment, %Position{} = position) when is_binary(fragment) do + pos = {position.line, position.character} + + case Code.Fragment.surround_context(fragment, pos) do + :none -> do_surround_context_again(fragment, pos) + context -> {:ok, context} + end + end + + defp do_surround_context_again(_fragment, {_line, 1} = _position) do + {:error, :surround_context} + end + + defp do_surround_context_again(fragment, {line, column} = position) do + case Code.Fragment.surround_context(fragment, {line, column - 1}) do + :none -> + {:error, :surround_context} + + context -> + if context.end == position do + {:ok, context} + else + {:error, :surround_context} + end + end + end + + defp patch_to_range(document, start_pos, end_pos) do + with {:ok, start_pos} <- patch_to_position(document, start_pos), + {:ok, end_pos} <- patch_to_position(document, end_pos) do + {:ok, Range.new(start_pos, end_pos)} + end + end + + defp patch_to_position(document, patch_keyword) do + with {:ok, line} <- Keyword.fetch(patch_keyword, :line), + {:ok, column} <- Keyword.fetch(patch_keyword, :column) do + {:ok, Position.new(document, line, column)} + end + end + + defp zipper_at_position(ast, position) do + zipper = + ast + |> Zipper.zip() + |> Zipper.find(fn node -> + at_or_after?(node, position) + end) + + if zipper do + {:ok, zipper} + else + {:error, :not_found} + end + end + + # in the future, I'd like to expose functions that only traverse a section of the document, + # but presently, traverse only follows a subtree, so it won't work for our purposes + defp traverse_in(%Document{} = document, %Range{} = range, fun) do + ignore_acc = fn node, acc -> + {fun.(node), acc} + end + + case traverse_in(document, range, [], ignore_acc) do + {:ok, zipper, _} -> + {:ok, zipper} + + error -> + error + end + end + + defp traverse_in(%Document{} = document, %Range{} = range, acc, fun) do + with {:ok, zipper} <- zipper_at(document, range.start) do + {zipper, {_position, acc}} = + Zipper.traverse_while( + zipper, + {{0, 0}, acc}, + fn %Zipper{node: node} = zipper, {last_position, acc} -> + current_position = node_position(node, last_position) + + if within?(current_position, range.start, range.end) do + {zipper, new_acc} = fun.(zipper, acc) + + {:cont, zipper, {current_position, new_acc}} + else + {:skip, zipper, {current_position, acc}} + end + end + ) + + {:ok, zipper, acc} + end + end + + defp within?(pos, start_pos, end_pos) do + Position.compare(pos, start_pos) in [:gt, :eq] and + Position.compare(pos, end_pos) in [:lt, :eq] + end + + defp at_or_after?(node, %Position{} = position) do + node_position = node_position(node, {0, 0}) + + Position.compare(node_position, position) in [:gt, :eq] + end + + defp one_line_range(%Document{} = document, line_number) do + start_pos = Position.new(document, line_number, 1) + end_pos = Position.new(document, line_number + 1, 0) + Range.new(start_pos, end_pos) + end + + defp node_position(node, {line, column}) do + {get_line(node, line), get_column(node, column)} + end + + defp get_line([{:do, node}], default) do + get_line(node, default) + end + + defp get_line({:do, node}, default) do + get_line(node, default) + end + + defp get_line(node, default) when is_tuple(node) and tuple_size(node) == 3 do + Sourceror.get_line(node, default) + end + + defp get_line(_, default) do + default + end + + defp get_column([do: node], default) do + get_column(node, default) + end + + defp get_column({:do, node}, default) do + get_column(node, default) + end + + defp get_column(node, default) when is_tuple(node) and tuple_size(node) == 3 do + Sourceror.get_column(node, default) + end + + defp get_column(_, default) do + default + end + + # Similar to `Future.Macro.path/3`, but returns the path to the innermost + # node for which `fun` returns truthy instead of the path to the first node + # that returns such. + defp innermost_path(ast, acc, fun) + + defp innermost_path({form, _, args} = ast, acc, fun) when is_atom(form) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path_args(args, acc, fun) || acc + else + innermost_path_args(args, acc, fun) + end + end + + defp innermost_path({form, _meta, args} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path(form, acc, fun) || innermost_path_args(args, acc, fun) || acc + else + innermost_path(form, acc, fun) || innermost_path_args(args, acc, fun) + end + end + + defp innermost_path({left, right} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path(left, acc, fun) || innermost_path(right, acc, fun) || acc + else + innermost_path(left, acc, fun) || innermost_path(right, acc, fun) + end + end + + defp innermost_path(list, acc, fun) when is_list(list) do + acc = [list | acc] + + if fun.(list) do + innermost_path_list(list, acc, fun) || acc + else + innermost_path_list(list, acc, fun) + end + end + + defp innermost_path(ast, acc, fun) do + if fun.(ast) do + [ast | acc] + end + end + + defp innermost_path_args(atom, _acc, _fun) when is_atom(atom), do: nil + + defp innermost_path_args(list, acc, fun) when is_list(list) do + innermost_path_list(list, acc, fun) + end + + defp innermost_path_list([], _acc, _fun) do + nil + end + + defp innermost_path_list([arg | args], acc, fun) do + innermost_path(arg, acc, fun) || innermost_path_list(args, acc, fun) + end + + defp normalize_position(%Position{} = position, _document), do: position + + defp normalize_position({line, character}, %Document{} = document) do + Position.new(document, line, character) + end +end diff --git a/forge/lib/forge/ast/analysis.ex b/forge/lib/forge/ast/analysis.ex new file mode 100644 index 00000000..e2ecd2a8 --- /dev/null +++ b/forge/lib/forge/ast/analysis.ex @@ -0,0 +1,539 @@ +defmodule Forge.Ast.Analysis do + @moduledoc """ + A data structure representing an analyzed AST. + + See `Forge.Ast.analyze/1`. + """ + + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Analysis.State + alias Forge.Ast.Analysis.Use + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Identifier + alias Sourceror.Zipper + + defstruct [:ast, :document, :parse_error, scopes: [], comments_by_line: %{}, valid?: true] + + @type t :: %__MODULE__{} + @scope_id :_scope_id + + @block_keywords [:do, :else, :rescue, :catch, :after] + @clauses [:->] + + @doc false + def new(parse_result, document) + + def new({:ok, ast}, %Document{} = document) do + new({:ok, ast, []}, document) + end + + def new({:ok, ast, comments}, %Document{} = document) do + scopes = traverse(ast, document) + comments_by_line = Map.new(comments, fn comment -> {comment.line, comment} end) + + %__MODULE__{ + ast: ast, + document: document, + scopes: scopes, + comments_by_line: comments_by_line + } + end + + def new(error, document) do + %__MODULE__{ + document: document, + parse_error: error, + valid?: false + } + end + + @doc """ + Returns the scopes for the given position, sorted by nearest proximity. + """ + def scopes_at(%__MODULE__{scopes: scopes}, %Position{} = position) do + scopes + |> Enum.filter(fn %Scope{range: range} = scope -> + scope.id == :global or Range.contains?(range, position) + end) + |> Enum.sort_by( + fn + %Scope{id: :global} -> 0 + %Scope{range: range} -> {range.start.line, range.start.character} + end, + :desc + ) + end + + @doc false + def scope_id({_, meta, _}) when is_list(meta) do + Keyword.get(meta, @scope_id) + end + + def scope_id({left, right}) do + {scope_id(left), scope_id(right)} + end + + def scope_id(list) when is_list(list) do + Enum.map(list, &scope_id/1) + end + + def scope_id(_) do + nil + end + + def commented?(%__MODULE__{} = analysis, %Position{} = position) do + case Map.fetch(analysis.comments_by_line, position.line) do + {:ok, comment} -> position.character > comment[:column] + _ -> false + end + end + + @doc """ + Returns the scope of the nearest enclosing module of the given function. + + If there is no enclosing module scope, the global scope is returned + """ + @spec module_scope(t(), Range.t()) :: Scope.t() + def module_scope(%__MODULE__{} = analysis, %Range{} = range) do + enclosing_scopes = + analysis + |> scopes_at(range.start) + |> enclosing_scopes(range) + + first_scope = List.first(enclosing_scopes) + + Enum.reduce_while(enclosing_scopes, first_scope, fn + %Scope{module: same} = current, %Scope{module: same} -> + {:cont, current} + + _, current -> + {:halt, current} + end) + end + + defp enclosing_scopes(scopes, range) do + Enum.filter(scopes, fn scope -> + Range.contains?(scope.range, range.start) + end) + end + + defp traverse(quoted, %Document{} = document) do + quoted = preprocess(quoted) + + {_, state} = + Macro.traverse( + quoted, + State.new(document), + fn quoted, state -> + case analyze_node(quoted, state) do + {new_quoted, new_state} -> + {new_quoted, new_state} + + new_state -> + {quoted, new_state} + end + end, + fn quoted, state -> + case {scope_id(quoted), State.current_scope(state)} do + {id, %Scope{id: id}} -> + {quoted, State.pop_scope(state)} + + _ -> + {quoted, state} + end + end + ) + + unless length(state.scopes) == 1 do + raise RuntimeError, + "invariant not met, :scopes should only contain the global scope: #{inspect(state)}" + end + + state + # pop the final, global state + |> State.pop_scope() + |> Map.fetch!(:visited) + |> Map.reject(fn {_id, scope} -> Scope.empty?(scope) end) + |> correct_ranges(quoted, document) + |> Map.values() + end + + defp preprocess(quoted) do + Macro.prewalk(quoted, &with_scope_id/1) + end + + defp correct_ranges(scopes, quoted, document) do + {_zipper, scopes} = + quoted + |> Zipper.zip() + |> Zipper.traverse(scopes, fn %Zipper{node: node} = zipper, scopes -> + id = scope_id(node) + + if scope = scopes[id] do + {zipper, Map.put(scopes, id, maybe_correct_range(scope, zipper, document))} + else + {zipper, scopes} + end + end) + + scopes + end + + # extend range for block pairs to either the beginning of their next + # sibling or, if they are the last element, the end of their parent + defp maybe_correct_range(scope, %Zipper{node: {_, _}} = zipper, %Document{} = document) do + with %Zipper{node: sibling} <- Zipper.right(zipper), + %{start: sibling_start} <- Sourceror.get_range(sibling) do + new_end = Position.new(document, sibling_start[:line], sibling_start[:column]) + put_in(scope.range.end, new_end) + else + _ -> + # we go up twice to get to the real parent because ast pairs + # are always in a list + %Zipper{node: parent} = zipper |> Zipper.up() |> Zipper.up() + + case Sourceror.get_range(parent) do + %{end: parent_end} -> + new_end = Position.new(document, parent_end[:line], parent_end[:column]) + put_in(scope.range.end, new_end) + + _ -> + scope + end + end + end + + defp maybe_correct_range(scope, _zipper, _document) do + scope + end + + # add a unique ID to 3-element tuples + defp with_scope_id({_, _, _} = quoted) do + id = Identifier.next_global!() + Macro.update_meta(quoted, &Keyword.put(&1, @scope_id, id)) + end + + defp with_scope_id(quoted) do + quoted + end + + @skip :skipped? + + defp skip_leading_do({_, meta, _} = root_ast) do + # Marks the first do block after the passed in node. This is because + # that do block doesn't have accurate ending information, and if we build + # a scope around it, it won't end properly, which will cause information + # contained in scopes to leak out of them. + + case Keyword.fetch(meta, :do) do + {:ok, [line: line, column: column]} -> + Macro.prewalk(root_ast, fn + {:__block__, _meta, [:do]} = block_ast -> + case Sourceror.get_start_position(block_ast) do + [line: ^line, column: ^column] -> + skip(block_ast) + + _ -> + block_ast + end + + other -> + other + end) + + _ -> + root_ast + end + end + + defp skip({_, _, _} = quoted) do + Macro.update_meta(quoted, &Keyword.put(&1, @skip, true)) + end + + defp skipped?({_, meta, _}) when is_list(meta) do + skipped?(meta) + end + + defp skipped?(meta) when is_list(meta) do + Keyword.get(meta, @skip, false) + end + + defp skipped?(_), do: false + + @module_defining_forms [:defmodule, :defprotocol] + # defmodule Foo do or defprotocol MyProtocol do + defp analyze_node({form, _meta, [{:__aliases__, _, segments} | _]} = quoted, state) + when form in @module_defining_forms do + module = + case State.current_module(state) do + [] -> segments + current_module -> reify_alias(current_module, segments) + end + + current_module_alias = Alias.implicit(state.document, quoted, module, :__MODULE__) + + new_state = + state + # implicit alias belongs to the current scope + |> maybe_push_implicit_alias(segments, state.document, quoted) + # new __MODULE__ alias belongs to the new scope + |> State.push_scope_for(quoted, module) + |> State.push_alias(current_module_alias) + + {skip_leading_do(quoted), new_state} + end + + # defimpl Foo, for: SomeProtocol do + defp analyze_node( + {:defimpl, _meta, + [ + {:__aliases__, _, protocol_segments}, + [{_for_keyword, {:__aliases__, _, for_segments}}] | _ + ]} = quoted, + state + ) do + expanded_for = expand_alias(for_segments, state) + module = expand_alias(protocol_segments ++ expanded_for, state) + current_module_alias = Alias.implicit(state.document, quoted, module, :__MODULE__) + for_alias = Alias.implicit(state.document, quoted, expanded_for, :"@for") + protocol_alias = Alias.implicit(state.document, quoted, protocol_segments, :"@protocol") + + new_state = + state + |> State.push_scope_for(quoted, module) + |> State.push_alias(current_module_alias) + |> State.push_alias(for_alias) + |> State.push_alias(protocol_alias) + + {skip_leading_do(quoted), new_state} + end + + # alias Foo.{Bar, Baz, Buzz.Qux} + defp analyze_node( + {:alias, _meta, [{{:., _, [aliases, :{}]}, _, aliases_nodes}]} = quoted, + state + ) do + base_segments = expand_alias(aliases, state) + + Enum.reduce(aliases_nodes, state, fn {:__aliases__, _, segments}, state -> + alias = + Alias.explicit(state.document, quoted, base_segments ++ segments, List.last(segments)) + + State.push_alias(state, alias) + end) + end + + # alias Foo + # alias Foo.Bar + # alias __MODULE__.Foo + defp analyze_node({:alias, _meta, [aliases]} = quoted, state) do + case expand_alias(aliases, state) do + [_ | _] = segments -> + alias = Alias.explicit(state.document, quoted, segments, List.last(segments)) + State.push_alias(state, alias) + + [] -> + state + end + end + + # alias Foo, as: Bar + defp analyze_node({:alias, meta, [aliases, options]} = quoted, state) do + with {:ok, alias_as} <- fetch_alias_as(options), + [_ | _] = segments <- expand_alias(aliases, state) do + alias = Alias.explicit(state.document, quoted, segments, alias_as) + State.push_alias(state, alias) + else + _ -> + analyze_node({:alias, meta, [aliases]}, state) + end + end + + # import with selector import MyModule, only: :functions + defp analyze_node( + {:import, _meta, [{:__aliases__, _aliases, module}, selector]} = quoted, + state + ) do + State.push_import(state, Import.new(state.document, quoted, module, selector)) + end + + # wholesale import import MyModule + defp analyze_node({:import, _meta, [{:__aliases__, _aliases, module}]} = quoted, state) do + State.push_import(state, Import.new(state.document, quoted, module)) + end + + # require MyModule, as: Alias + defp analyze_node({:require, _meta, [{:__aliases__, _, module}, options]} = quoted, state) do + case fetch_alias_as(options) do + {:ok, as_module} -> + State.push_require(state, Require.new(state.document, quoted, module, as_module)) + + :error -> + state + end + end + + # require MyModule + defp analyze_node( + {:require, _meta, [{:__aliases__, _, module}]} = quoted, + state + ) do + State.push_require(state, Require.new(state.document, quoted, module)) + end + + # use MyModule + defp analyze_node( + {:use, _meta, [{:__aliases__, _, module} | opts]} = use, + state + ) do + State.push_use(state, Use.new(state.document, use, module, opts)) + end + + # stab clauses: -> + defp analyze_node({clause, _, _} = quoted, state) when clause in @clauses do + maybe_push_scope_for(state, quoted) + end + + # blocks: do, else, etc. + defp analyze_node({{:__block__, meta, [block]}, _} = quoted, state) + when block in @block_keywords do + if skipped?(meta) do + state + else + maybe_push_scope_for(state, quoted) + end + end + + # catch-all + defp analyze_node(_quoted, state) do + state + end + + defp maybe_push_implicit_alias(%State{} = state, [first_segment | _], document, quoted) + when is_atom(first_segment) do + segments = + case State.current_module(state) do + # the head element of top-level modules can be aliased, so we + # must expand them + [] -> + expand_alias([first_segment], state) + + # if we have a current module, we prefix the first segment with it + current_module -> + current_module ++ [first_segment] + end + + implicit_alias = Alias.implicit(document, quoted, segments, first_segment) + State.push_alias(state, implicit_alias) + end + + # don't create an implicit alias if the module is defined using complex forms: + # defmodule __MODULE__.Foo do + # defmodule unquote(...) do + defp maybe_push_implicit_alias(%State{} = state, [non_atom | _], _, _) + when not is_atom(non_atom) do + state + end + + defp expand_alias({:__MODULE__, _, nil}, state) do + State.current_module(state) + end + + defp expand_alias({:__aliases__, _, segments}, state) do + expand_alias(segments, state) + end + + defp expand_alias([{:__MODULE__, _, nil} | segments], state) do + State.current_module(state) ++ segments + end + + defp expand_alias([first | rest], state) do + alias_map = state |> State.current_scope() |> Scope.alias_map() + + case alias_map do + %{^first => existing_alias} -> + existing_alias.module ++ rest + + _ -> + [first | rest] + end + end + + defp expand_alias(quoted, state) do + reify_alias(State.current_module(state), List.wrap(quoted)) + end + + # Expands aliases given the rules in the special form + # https://hexdocs.pm/elixir/1.13.4/Kernel.SpecialForms.html#__aliases__/1 + + # When the head element is the atom :"Elixir", no expansion happens + defp reify_alias(_, [:"Elixir" | _] = reified) do + reified + end + + # Without a current module, we can't expand a non-atom head element + defp reify_alias([], [non_atom | rest]) when not is_atom(non_atom) do + rest + end + + # With no current module and an atom head, no expansion occurs + defp reify_alias([], [atom | _] = reified) when is_atom(atom) do + reified + end + + # Expand current module + defp reify_alias(current_module, [{:__MODULE__, _, nil} | rest]) do + current_module ++ rest + end + + # With a current module and an atom head, the alias is nested in the + # current module + defp reify_alias(current_module, [atom | _rest] = reified) when is_atom(atom) do + current_module ++ reified + end + + # In other cases, attempt to expand the unreified head element + defp reify_alias(current_module, [unreified | rest]) do + module = Module.concat(current_module) + env = %Macro.Env{module: module} + reified = Macro.expand(unreified, env) + + if is_atom(reified) do + reified_segments = reified |> Module.split() |> Enum.map(&String.to_atom/1) + reified_segments ++ rest + else + rest + end + end + + defp fetch_alias_as(options) when is_list(options) do + alias_as = + Enum.find_value(options, fn + {{:__block__, _, [:as]}, {:__aliases__, _, [alias_as]}} -> alias_as + _ -> nil + end) + + case alias_as do + nil -> :error + _ -> {:ok, alias_as} + end + end + + # When the `as` section is incomplete, like: `alias Foo, a` + defp fetch_alias_as(_) do + :error + end + + defp maybe_push_scope_for(%State{} = state, ast) do + if skipped?(ast) do + state + else + State.maybe_push_scope_for(state, ast) + end + end +end diff --git a/forge/lib/forge/ast/analysis/alias.ex b/forge/lib/forge/ast/analysis/alias.ex new file mode 100644 index 00000000..ca46f60b --- /dev/null +++ b/forge/lib/forge/ast/analysis/alias.ex @@ -0,0 +1,52 @@ +defmodule Forge.Ast.Analysis.Alias do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [:module, :as, :range, explicit?: true] + + @type t :: %__MODULE__{ + module: [atom], + as: module(), + range: Range.t() | nil + } + + def explicit(%Document{} = document, ast, module, as) when is_list(module) do + range = range_for_ast(document, ast, module, as) + %__MODULE__{module: module, as: as, range: range} + end + + def implicit(%Document{} = document, ast, module, as) when is_list(module) do + range = implicit_range(document, ast) + %__MODULE__{module: module, as: as, range: range, explicit?: false} + end + + def to_module(%__MODULE__{} = alias) do + Module.concat(alias.module) + end + + @implicit_aliases [:__MODULE__, :"@for", :"@protocol"] + defp range_for_ast(document, ast, _alias, as) when as in @implicit_aliases do + implicit_range(document, ast) + end + + defp range_for_ast(document, ast, _alias, _as) do + # All other kinds of aliases defined with the `alias` special form + Ast.Range.get(ast, document) + end + + defp implicit_range(%Document{} = document, ast) do + # There are kinds of aliases that are automatically generated by elixir + # such as __MODULE__, these don't really have any code that defines them, + with [line: line, column: _] <- Sourceror.get_start_position(ast), + {:ok, line_text} <- Document.fetch_text_at(document, line) do + line_length = String.length(line_text) + alias_start = Position.new(document, line, line_length) + Range.new(alias_start, alias_start) + else + _ -> + nil + end + end +end diff --git a/forge/lib/forge/ast/analysis/import.ex b/forge/lib/forge/ast/analysis/import.ex new file mode 100644 index 00000000..d541cf2b --- /dev/null +++ b/forge/lib/forge/ast/analysis/import.ex @@ -0,0 +1,92 @@ +defmodule Forge.Ast.Analysis.Import do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Range + + defstruct module: nil, selector: :all, range: nil, explicit?: true + + @type function_name :: atom() + @type function_arity :: {function_name(), arity()} + @type selector :: + :functions + | :macros + | :sigils + | [only: [function_arity()]] + | [except: [function_arity()]] + @type t :: %{ + module: module(), + selector: selector(), + line: non_neg_integer() + } + def new(%Document{} = document, ast, module) do + %__MODULE__{module: module, range: Ast.Range.get(ast, document)} + end + + def new(%Document{} = document, ast, module, selector) do + %__MODULE__{ + module: module, + selector: expand_selector(selector), + range: Ast.Range.get(ast, document) + } + end + + def implicit(%Range{} = range, module) do + %__MODULE__{module: module, range: range, explicit?: false} + end + + defp expand_selector(selectors) when is_list(selectors) do + selectors = + Enum.reduce(selectors, [], fn + {{:__block__, _, [type]}, {:__block__, _, [selector]}}, acc + when type in [:only, :except] -> + expanded = + case selector do + :functions -> + :functions + + :macros -> + :macros + + :sigils -> + :sigils + + keyword when is_list(keyword) -> + keyword + |> Enum.reduce([], &expand_function_keywords/2) + |> Enum.reverse() + + _ -> + # they're likely in the middle of typing in something, and have produced an + # invalid import + [] + end + + [{type, expanded} | acc] + + _, acc -> + acc + end) + + if selectors == [] do + :all + else + selectors + end + end + + # If the selectors is not valid, like: `import SomeModule, o `, we default to :all + defp expand_selector(_) do + :all + end + + defp expand_function_keywords( + {{:__block__, _, [function_name]}, {:__block__, _, [arity]}}, + acc + ) + when is_atom(function_name) and is_number(arity) do + [{function_name, arity} | acc] + end + + defp expand_function_keywords(_ignored, acc), + do: acc +end diff --git a/forge/lib/forge/ast/analysis/require.ex b/forge/lib/forge/ast/analysis/require.ex new file mode 100644 index 00000000..9d0240f0 --- /dev/null +++ b/forge/lib/forge/ast/analysis/require.ex @@ -0,0 +1,10 @@ +defmodule Forge.Ast.Analysis.Require do + alias Forge.Ast + alias Forge.Document + defstruct [:module, :as, :range] + + def new(%Document{} = document, ast, module, as \\ nil) when is_list(module) do + range = Ast.Range.get(ast, document) + %__MODULE__{module: module, as: as || module, range: range} + end +end diff --git a/forge/lib/forge/ast/analysis/scope.ex b/forge/lib/forge/ast/analysis/scope.ex new file mode 100644 index 00000000..6304127c --- /dev/null +++ b/forge/lib/forge/ast/analysis/scope.ex @@ -0,0 +1,86 @@ +defmodule Forge.Ast.Analysis.Scope do + alias Forge.Ast.Analysis.Alias + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [ + :id, + :range, + module: [], + aliases: [], + imports: [], + requires: [], + uses: [] + ] + + @type import_mfa :: {module(), atom(), non_neg_integer()} + @type scope_position :: Position.t() | Position.line() | :end + + @type t :: %__MODULE__{ + id: any(), + range: Range.t(), + module: [atom()], + aliases: [Alias.t()], + imports: [import_mfa()] + } + + def new(%__MODULE__{} = parent_scope, id, %Range{} = range, module \\ []) do + uses = + if module == parent_scope.module do + # if we're still in the same module, we have the same uses + parent_scope.uses + else + [] + end + + %__MODULE__{ + id: id, + aliases: parent_scope.aliases, + imports: parent_scope.imports, + requires: parent_scope.requires, + module: module, + range: range, + uses: uses + } + end + + def global(%Range{} = range) do + %__MODULE__{id: :global, range: range} + end + + @spec alias_map(t(), scope_position()) :: %{module() => t()} + def alias_map(%__MODULE__{} = scope, position \\ :end) do + scope.aliases + # sorting by line ensures that aliases on later lines + # override aliases on earlier lines + |> Enum.sort_by(& &1.range.start.line) + |> Enum.take_while(fn %Alias{range: alias_range} -> + case position do + %Position{} = pos -> + pos.line >= alias_range.start.line + + line when is_integer(line) -> + line >= alias_range.start.line + + :end -> + true + end + end) + |> Map.new(&{&1.as, &1}) + end + + def fetch_alias_with_prefix(%__MODULE__{} = scope, prefix) do + case Enum.find(scope.aliases, fn %Alias{} = alias -> alias.as == prefix end) do + %Alias{} = existing -> {:ok, existing} + _ -> :error + end + end + + def empty?(%__MODULE__{id: :global}), do: false + def empty?(%__MODULE__{aliases: [], imports: []}), do: true + def empty?(%__MODULE__{}), do: false + + def end_line(%__MODULE__{} = scope, :end), do: scope.range.end.line + def end_line(_, %Position{} = position), do: position.line + def end_line(_, line) when is_integer(line), do: line +end diff --git a/forge/lib/forge/ast/analysis/state.ex b/forge/lib/forge/ast/analysis/state.ex new file mode 100644 index 00000000..5972d3ad --- /dev/null +++ b/forge/lib/forge/ast/analysis/state.ex @@ -0,0 +1,180 @@ +defmodule Forge.Ast.Analysis.State do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Analysis.Use + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [:document, scopes: [], visited: %{}] + + def new(%Document{} = document) do + state = %__MODULE__{document: document} + + scope = + document + |> global_range() + |> Scope.global() + + push_scope(state, scope) + end + + def current_scope(%__MODULE__{scopes: [scope | _]}), do: scope + + def current_module(%__MODULE__{} = state) do + current_scope(state).module + end + + def push_scope(%__MODULE__{} = state, %Scope{} = scope) do + Map.update!(state, :scopes, &[scope | &1]) + end + + def push_scope(%__MODULE__{} = state, id, %Range{} = range, module) when is_list(module) do + scope = + state + |> current_scope() + |> Scope.new(id, range, module) + + push_scope(state, scope) + end + + def push_scope_for(%__MODULE__{} = state, quoted, %Range{} = range, module) do + module = module || current_module(state) + + id = Analysis.scope_id(quoted) + push_scope(state, id, range, module) + end + + def push_scope_for(%__MODULE__{} = state, quoted, module) do + range = get_range(quoted, state.document) + push_scope_for(state, quoted, range, module) + end + + def maybe_push_scope_for(%__MODULE__{} = state, quoted) do + case get_range(quoted, state.document) do + %Range{} = range -> + push_scope_for(state, quoted, range, nil) + + nil -> + state + end + end + + def pop_scope(%__MODULE__{scopes: [scope | rest]} = state) do + %__MODULE__{state | scopes: rest, visited: Map.put(state.visited, scope.id, scope)} + end + + def push_alias(%__MODULE__{} = state, %Alias{} = alias) do + update_current_scope(state, fn %Scope{} = scope -> + [prefix | rest] = alias.module + + alias = + case Scope.fetch_alias_with_prefix(scope, prefix) do + {:ok, %Alias{} = existing_alias} -> + %Alias{alias | module: existing_alias.module ++ rest} + + :error -> + alias + end + + Map.update!(scope, :aliases, &[alias | &1]) + end) + end + + def push_import(%__MODULE__{} = state, %Import{} = import) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :imports, &[import | &1]) + end) + end + + def push_require(%__MODULE__{} = state, %Require{} = require) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :requires, &[require | &1]) + end) + end + + def push_use(%__MODULE__{} = state, %Use{} = use) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :uses, &[use | &1]) + end) + end + + defp update_current_scope(%__MODULE__{} = state, fun) do + update_in(state, [Access.key(:scopes), Access.at!(0)], fn %Scope{} = scope -> + fun.(scope) + end) + end + + # if there is no code after a stab operator, then the end position + # it gives us can be in the middle of the line, as it's derived from + # the start of some entity on the last line. So we increment the line + # by one, and that should be the end of the stab block + defp get_range({:->, _, _} = quoted, %Document{} = document) do + start_pos = get_start_position(quoted) + + case Sourceror.get_end_position(quoted, line: -1, column: -1) do + [line: -1, column: -1] -> + nil + + [line: line, column: 1] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, line + 1, 1) + ) + + [line: line, column: _] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, line + 1, 1) + ) + end + end + + defp get_range(quoted, %Document{} = document) do + start_pos = get_start_position(quoted) + + case Sourceror.get_end_position(quoted, line: -1, column: -1) do + [line: -1, column: -1] -> + nil + + [line: end_line, column: end_column] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, end_line, end_column) + ) + end + end + + defp global_range(%Document{} = document) do + num_lines = Document.size(document) + + Range.new( + Position.new(document, 1, 1), + Position.new(document, num_lines + 1, 1) + ) + end + + defp get_start_position({_, metadata, _} = ast) do + case Keyword.fetch(metadata, :do) do + {:ok, [line: line, column: column]} -> + # add 2 to position us after the do keyword + [line: line, column: column + 2] + + _ -> + Sourceror.get_start_position(ast) + end + end + + defp get_start_position({block_meta, _rest}) do + case Sourceror.get_start_position(block_meta) do + [line: line, column: column] -> + [line: line, column: column + 2] + + other -> + other + end + end +end diff --git a/forge/lib/forge/ast/analysis/use.ex b/forge/lib/forge/ast/analysis/use.ex new file mode 100644 index 00000000..7891e0f1 --- /dev/null +++ b/forge/lib/forge/ast/analysis/use.ex @@ -0,0 +1,10 @@ +defmodule Forge.Ast.Analysis.Use do + alias Forge.Ast + alias Forge.Document + defstruct [:module, :range, :opts] + + def new(%Document{} = document, ast, module, opts) do + range = Ast.Range.get(ast, document) + %__MODULE__{range: range, module: module, opts: opts} + end +end diff --git a/forge/lib/forge/ast/detection.ex b/forge/lib/forge/ast/detection.ex new file mode 100644 index 00000000..9b64fee3 --- /dev/null +++ b/forge/lib/forge/ast/detection.ex @@ -0,0 +1,109 @@ +defmodule Forge.Ast.Detection do + @moduledoc """ + A behavior for context detection + + A context recognizer can recognize the type of code at a current position. + It is useful for identifying the "part of speech" of a position. + + Note: a given context might be detected by more than one module. + """ + + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range + + @doc """ + Returns true if the given position is detected by the current module + """ + @callback detected?(Analysis.t(), Position.t()) :: boolean() + + defmacro __using__(_) do + quote do + @behaviour unquote(__MODULE__) + import unquote(__MODULE__) + end + end + + def ancestor_is_def?(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Ast.cursor_path(position) + |> Enum.any?(fn + {:def, _, _} -> + true + + {:defp, _, _} -> + true + + _ -> + false + end) + end + + @type_keys [:type, :typep, :opaque] + def ancestor_is_type?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position, @type_keys) + end + + def ancestor_is_spec?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position, :spec) + end + + def ancestor_is_attribute?(%Analysis{} = analysis, %Position{} = position, attr_name \\ nil) do + analysis + |> Ast.cursor_path(position) + |> Enum.any?(fn + {:@, metadata, [{found_name, _, _}]} -> + # single line attribute + attribute_names_match?(attr_name, found_name) and cursor_in_range?(position, metadata) + + {:__block__, _, [{:@, metadata, [{found_name, _, _}]}, _]} -> + # multi-line attribute + attribute_names_match?(attr_name, found_name) and cursor_in_range?(position, metadata) + + _ -> + false + end) + end + + def fetch_range(ast) do + fetch_range(ast, 0, 0) + end + + def fetch_range(ast, start_offset, end_offset) do + case Sourceror.get_range(ast) do + %{start: [line: start_line, column: start_col], end: [line: end_line, column: end_col]} -> + range = + Range.new( + %Position{line: start_line, character: start_col + start_offset}, + %Position{line: end_line, character: end_col + end_offset} + ) + + {:ok, range} + + nil -> + :error + end + end + + defp cursor_in_range?(position, metadata) do + expression_end_line = get_in(metadata, [:end_of_expression, :line]) + expression_end_column = get_in(metadata, [:end_of_expression, :column]) + cursor_line = position.line + cursor_column = position.character + + if cursor_line == expression_end_line do + expression_end_column > cursor_column + else + cursor_line < expression_end_line + end + end + + defp attribute_names_match?(expected_names, actual_name) + when is_list(expected_names), + do: actual_name in expected_names + + defp attribute_names_match?(nil, _), do: true + defp attribute_names_match?(same, same), do: true + defp attribute_names_match?(_, _), do: false +end diff --git a/forge/lib/forge/ast/detection/alias.ex b/forge/lib/forge/ast/detection/alias.ex new file mode 100644 index 00000000..0ba863a0 --- /dev/null +++ b/forge/lib/forge/ast/detection/alias.ex @@ -0,0 +1,64 @@ +defmodule Forge.Ast.Detection.Alias do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @doc """ + Recognizes an alias at the current position + + Aliases are complicated, especially if we're trying to find out if we're in + them from the current cursor position moving backwards. + I'll try to describe the state machine below. + First off, if we're outside of a } on the current line, we cannot be in an alias, so that + halts with false. + Similarly an alias on the current line is also simple, we just backtrack until we see the alias identifier. + However, if we're on the current line, and see an EOL, we set that as our accumulator, then we get + to the previous line, we see if it ends in a comma. If not, we can't be in an alias. If it does, we keep + backtracking until we hit the alias keyword. + So basically, if we hit an EOL, and the previous token isn't an open curly or a comma, we stop, otherwise + we backtrack until we hit the alias keyword + """ + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + result = + analysis.document + |> Tokens.prefix_stream(position) + |> Stream.with_index() + |> Enum.reduce_while(false, fn + {{:curly, :"{", _}, _index}, :eol -> + {:cont, false} + + {{:comma, _, _}, _index}, :eol -> + {:cont, false} + + {{:eol, _, _}, _index}, _acc -> + {:cont, :eol} + + {{_, _, _}, _}, :eol -> + {:halt, false} + + {{:curly, :"}", _}, _index}, _ -> + {:halt, false} + + {{:identifier, ~c"alias", _}, 0}, _ -> + # there is nothing after the alias directive, so we're not + # inside the context *yet* + + {:halt, false} + + {{:identifier, ~c"alias", _}, _index}, _ -> + {:halt, true} + + _, _ -> + {:cont, false} + end) + + case result do + b when is_boolean(b) -> b + :eol -> false + end + end +end diff --git a/forge/lib/forge/ast/detection/bitstring.ex b/forge/lib/forge/ast/detection/bitstring.ex new file mode 100644 index 00000000..13f0d3b2 --- /dev/null +++ b/forge/lib/forge/ast/detection/bitstring.ex @@ -0,0 +1,26 @@ +defmodule Forge.Ast.Detection.Bitstring do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + document = analysis.document + Document.fragment(document, Position.new(document, position.line, 1), position) + + document + |> Tokens.prefix_stream(position) + |> Enum.reduce_while( + false, + fn + {:operator, :">>", _}, _ -> {:halt, false} + {:operator, :"<<", _}, _ -> {:halt, true} + _, _ -> {:cont, false} + end + ) + end +end diff --git a/forge/lib/forge/ast/detection/comment.ex b/forge/lib/forge/ast/detection/comment.ex new file mode 100644 index 00000000..f3dd652c --- /dev/null +++ b/forge/lib/forge/ast/detection/comment.ex @@ -0,0 +1,8 @@ +defmodule Forge.Ast.Detection.Comment do + alias Forge.Ast.Analysis + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position) do + Analysis.commented?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/directive.ex b/forge/lib/forge/ast/detection/directive.ex new file mode 100644 index 00000000..e0243d8e --- /dev/null +++ b/forge/lib/forge/ast/detection/directive.ex @@ -0,0 +1,21 @@ +defmodule Forge.Ast.Detection.Directive do + alias Forge.Ast.Analysis + alias Forge.Ast.Tokens + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position, directive_type) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.to_list() + |> Enum.reduce_while(false, fn + {:identifier, ^directive_type, _}, _ -> + {:halt, true} + + {:eol, _, _}, _ -> + {:halt, false} + + _, _ -> + {:cont, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/function_capture.ex b/forge/lib/forge/ast/detection/function_capture.ex new file mode 100644 index 00000000..85d5d726 --- /dev/null +++ b/forge/lib/forge/ast/detection/function_capture.ex @@ -0,0 +1,32 @@ +defmodule Forge.Ast.Detection.FunctionCapture do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.reduce_while(false, fn + {:paren, :")", _}, _ -> + {:halt, false} + + {:operator, :&, _}, _ -> + {:halt, true} + + {:int, _, _} = maybe_arity, _ -> + {:cont, maybe_arity} + + {:operator, :/, _}, {:int, _, _} -> + # if we encounter a trailing / in the prefix, the + # function capture is complete, and we're not inside it + {:halt, false} + + _, _ -> + {:cont, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/import.ex b/forge/lib/forge/ast/detection/import.ex new file mode 100644 index 00000000..9684e75f --- /dev/null +++ b/forge/lib/forge/ast/detection/import.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Import do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"import") + end +end diff --git a/forge/lib/forge/ast/detection/module_attribute.ex b/forge/lib/forge/ast/detection/module_attribute.ex new file mode 100644 index 00000000..38e128ce --- /dev/null +++ b/forge/lib/forge/ast/detection/module_attribute.ex @@ -0,0 +1,16 @@ +defmodule Forge.Ast.Detection.ModuleAttribute do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position) + end + + def detected?(%Analysis{} = analysis, %Position{} = position, name) do + ancestor_is_attribute?(analysis, position, name) + end +end diff --git a/forge/lib/forge/ast/detection/pipe.ex b/forge/lib/forge/ast/detection/pipe.ex new file mode 100644 index 00000000..8ca61f93 --- /dev/null +++ b/forge/lib/forge/ast/detection/pipe.ex @@ -0,0 +1,34 @@ +defmodule Forge.Ast.Detection.Pipe do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.to_list() + |> Enum.reduce_while(false, fn + {:identifier, _, _}, _ -> + {:cont, false} + + {:operator, :., _}, _ -> + {:cont, false} + + {:alias, _, _}, _ -> + {:cont, false} + + {:arrow_op, nil, _}, _ -> + {:halt, true} + + {:atom, _, _}, _ -> + {:cont, false} + + _, _acc -> + {:halt, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/require.ex b/forge/lib/forge/ast/detection/require.ex new file mode 100644 index 00000000..f989f1ea --- /dev/null +++ b/forge/lib/forge/ast/detection/require.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Require do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"require") + end +end diff --git a/forge/lib/forge/ast/detection/spec.ex b/forge/lib/forge/ast/detection/spec.ex new file mode 100644 index 00000000..7503a79a --- /dev/null +++ b/forge/lib/forge/ast/detection/spec.ex @@ -0,0 +1,12 @@ +defmodule Forge.Ast.Detection.Spec do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_spec?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/string.ex b/forge/lib/forge/ast/detection/string.ex new file mode 100644 index 00000000..adfeda6d --- /dev/null +++ b/forge/lib/forge/ast/detection/string.ex @@ -0,0 +1,109 @@ +defmodule Forge.Ast.Detection.String do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + alias Forge.Document.Position + alias Forge.Document.Range + + use Detection + + @string_sigils [ + :sigil_s, + :sigil_S + ] + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + detect_string(path, position) + + _ -> + false + end + end + + defp detect_string(paths, %Position{} = position) do + {_, detected?} = + Macro.postwalk(paths, false, fn + ast, false -> + detected? = do_detect(ast, position) + {ast, detected?} + + ast, true -> + {ast, true} + end) + + detected? + end + + # a string literal + defp do_detect({:__block__, _, [literal]} = ast, %Position{} = position) + when is_binary(literal) do + case fetch_range(ast, 0, -1) do + {:ok, range} -> Range.contains?(range, position) + :error -> false + end + end + + # a possible string with interpolation + defp do_detect({:<<>>, meta, _} = ast, %Position{} = position) do + # this might also be a binary match / construction + Keyword.has_key?(meta, :delimiter) and detect_interpolation(ast, position) + end + + # String sigils + defp do_detect({sigil, _, _} = ast, %Position{} = position) + when sigil in @string_sigils do + case fetch_range(ast, 0, 0) do + {:ok, range} -> Range.contains?(range, position) + _ -> false + end + end + + defp do_detect(_, _), + do: false + + # a string with interpolation + defp detect_interpolation( + {:<<>>, meta, interpolations} = ast, + %Position{} = position + ) do + delimiter_length = + meta + |> Keyword.get(:delimiter, "\"") + |> String.length() + + with {:ok, string_range} <- fetch_range(ast, delimiter_length, -1), + {:ok, interpolation_ranges} <- collect_interpolation_ranges(interpolations) do + Range.contains?(string_range, position) and + not Enum.any?(interpolation_ranges, &Range.contains?(&1, position)) + else + _ -> + false + end + end + + defp collect_interpolation_ranges(interpolations) do + {_, result} = + Macro.prewalk(interpolations, {:ok, []}, fn + ast, :error -> + {ast, :error} + + {:"::", _, _} = interpolation, {:ok, acc} -> + case fetch_range(interpolation, 1, -1) do + {:ok, range} -> + {interpolation, {:ok, [range | acc]}} + + :error -> + {interpolation, :error} + end + + ast, acc -> + {ast, acc} + end) + + result + end +end diff --git a/forge/lib/forge/ast/detection/struct_field_key.ex b/forge/lib/forge/ast/detection/struct_field_key.ex new file mode 100644 index 00000000..4d3d2635 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_field_key.ex @@ -0,0 +1,21 @@ +defmodule Forge.Ast.Detection.StructFieldKey do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + cursor_path = Ast.cursor_path(analysis, position) + + match?( + # in the key position, the cursor will always be followed by the + # map node because, in any other case, there will minimally be a + # 2-element key-value tuple containing the cursor + [{:__cursor__, _, _}, {:%{}, _, _}, {:%, _, _} | _], + cursor_path + ) + end +end diff --git a/forge/lib/forge/ast/detection/struct_field_value.ex b/forge/lib/forge/ast/detection/struct_field_value.ex new file mode 100644 index 00000000..3584190e --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_field_value.ex @@ -0,0 +1,11 @@ +defmodule Forge.Ast.Detection.StructFieldValue do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection.StructFieldKey + alias Forge.Ast.Detection.StructFields + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position) do + StructFields.detected?(analysis, position) and + not StructFieldKey.detected?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/struct_fields.ex b/forge/lib/forge/ast/detection/struct_fields.ex new file mode 100644 index 00000000..a1bfb8b8 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_fields.ex @@ -0,0 +1,15 @@ +defmodule Forge.Ast.Detection.StructFields do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Ast.cursor_path(position) + |> Enum.any?(&match?({:%, _, _}, &1)) + end +end diff --git a/forge/lib/forge/ast/detection/struct_reference.ex b/forge/lib/forge/ast/detection/struct_reference.ex new file mode 100644 index 00000000..2deec733 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_reference.ex @@ -0,0 +1,43 @@ +defmodule Forge.Ast.Detection.StructReference do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + case Ast.cursor_context(analysis, position) do + {:ok, {:struct, []}} -> + false + + {:ok, {:struct, _}} -> + true + + {:ok, {:local_or_var, [?_ | _rest] = possible_module_struct}} -> + # a reference to `%__MODULE`, often in a function head, as in + # def foo(%__) + + starts_with_percent? = + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.take(2) + |> Enum.any?(fn + {:percent, :%, _} -> true + _ -> false + end) + + starts_with_percent? and possible_dunder_module(possible_module_struct) and + (ancestor_is_def?(analysis, position) or ancestor_is_type?(analysis, position)) + + _ -> + false + end + end + + def possible_dunder_module(charlist) do + String.starts_with?("__MODULE__", to_string(charlist)) + end +end diff --git a/forge/lib/forge/ast/detection/type.ex b/forge/lib/forge/ast/detection/type.ex new file mode 100644 index 00000000..43ee1cbf --- /dev/null +++ b/forge/lib/forge/ast/detection/type.ex @@ -0,0 +1,12 @@ +defmodule Forge.Ast.Detection.Type do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_type?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/use.ex b/forge/lib/forge/ast/detection/use.ex new file mode 100644 index 00000000..0057b112 --- /dev/null +++ b/forge/lib/forge/ast/detection/use.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Use do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"use") + end +end diff --git a/forge/lib/forge/ast/env.ex b/forge/lib/forge/ast/env.ex new file mode 100644 index 00000000..af9db84b --- /dev/null +++ b/forge/lib/forge/ast/env.ex @@ -0,0 +1,238 @@ +defmodule Forge.Ast.Env do + @moduledoc """ + Representation of the environment at a given position in a document. + """ + + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + alias Forge.Project + + defstruct [ + :project, + :analysis, + :document, + :line, + :prefix, + :suffix, + :position, + :position_module, + :zero_based_character + ] + + @type t :: %__MODULE__{ + project: Project.t(), + analysis: Analysis.t(), + document: Document.t(), + line: String.t(), + prefix: String.t(), + suffix: String.t(), + position: Position.t(), + position_module: String.t(), + zero_based_character: non_neg_integer() + } + + @type token_value :: String.t() | charlist() | atom() + @type lexer_token :: {atom, token_value, {line :: pos_integer(), col :: pos_integer()}} + @type token_count :: pos_integer | :all + + @type context_type :: + :pipe + | :alias + | :struct_reference + | :struct_fields + | :struct_field_key + | :struct_field_value + | :function_capture + | :bitstring + | :comment + | :string + | :use + | :impl + | :spec + | :type + + def new(%Project{} = project, %Analysis{} = analysis, %Position{} = cursor_position) do + zero_based_character = cursor_position.character - 1 + + case Document.fetch_text_at(analysis.document, cursor_position.line) do + {:ok, line} -> + prefix = String.slice(line, 0, zero_based_character) + suffix = String.slice(line, zero_based_character..-1//1) + + analysis = Ast.reanalyze_to(analysis, cursor_position) + + cursor_module = + case Analysis.scopes_at(analysis, cursor_position) do + [%Scope{module: local_module} | _] -> + Enum.join(local_module, ".") + + [] -> + "" + end + + env = %__MODULE__{ + analysis: analysis, + document: analysis.document, + line: line, + position: cursor_position, + position_module: cursor_module, + prefix: prefix, + project: project, + suffix: suffix, + zero_based_character: zero_based_character + } + + {:ok, env} + + _ -> + {:error, {:out_of_bounds, cursor_position}} + end + end + + @spec prefix_tokens(t, token_count) :: [lexer_token] + def prefix_tokens(%__MODULE__{} = env, count \\ :all) do + stream = Tokens.prefix_stream(env.document, env.position) + + case count do + :all -> + stream + + count when is_integer(count) -> + Enum.take(stream, count) + end + end + + @spec in_context?(t, context_type) :: boolean() + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + def in_context?(%__MODULE__{} = env, context_type) do + analysis = env.analysis + position = env.position + + case context_type do + :alias -> + Detection.Alias.detected?(analysis, position) + + :behaviour -> + Detection.ModuleAttribute.detected?(analysis, position, :behaviour) + + :bitstring -> + Detection.Bitstring.detected?(analysis, position) + + :callback -> + Detection.ModuleAttribute.detected?(analysis, position, :callback) + + :comment -> + Detection.Comment.detected?(analysis, position) + + :doc -> + Detection.ModuleAttribute.detected?(analysis, position, :doc) + + :function_capture -> + Detection.FunctionCapture.detected?(analysis, position) + + :impl -> + Detection.ModuleAttribute.detected?(analysis, position, :impl) + + :import -> + Detection.Import.detected?(analysis, position) + + :module_attribute -> + Detection.ModuleAttribute.detected?(analysis, position) + + {:module_attribute, name} -> + Detection.ModuleAttribute.detected?(analysis, position, name) + + :macrocallback -> + Detection.ModuleAttribute.detected?(analysis, position, :macrocallback) + + :moduledoc -> + Detection.ModuleAttribute.detected?(analysis, position, :moduledoc) + + :pipe -> + Detection.Pipe.detected?(analysis, position) + + :require -> + Detection.Require.detected?(analysis, position) + + :spec -> + Detection.Spec.detected?(analysis, position) + + :string -> + Detection.String.detected?(analysis, position) + + :struct_fields -> + Detection.StructFields.detected?(analysis, position) + + :struct_field_key -> + Detection.StructFieldKey.detected?(analysis, position) + + :struct_field_value -> + Detection.StructFieldValue.detected?(analysis, position) + + :struct_reference -> + Detection.StructReference.detected?(analysis, position) + + :type -> + Detection.Type.detected?(analysis, position) + + :use -> + Detection.Use.detected?(analysis, position) + end + end + + @spec empty?(String.t()) :: boolean() + def empty?("") do + true + end + + def empty?(string) when is_binary(string) do + String.trim(string) == "" + end + + @doc """ + Returns the position of the next non-whitespace token on a line after `env.position`. + """ + @spec next_significant_position(t) :: {:ok, Position.t()} | :error + def next_significant_position(%__MODULE__{} = env) do + find_significant_position(env.document, env.position.line + 1, 1) + end + + @doc """ + Returns the position of the next non-whitespace token on a line before `env.position`. + """ + @spec prev_significant_position(t) :: {:ok, Position.t()} | :error + def prev_significant_position(%__MODULE__{} = env) do + find_significant_position(env.document, env.position.line - 1, -1) + end + + defp find_significant_position(%Document{} = document, line, inc_by) do + case Document.fetch_text_at(document, line) do + {:ok, text} -> + case fetch_leading_whitespace_count(text) do + {:ok, count} -> + {:ok, Position.new(document, line, count + 1)} + + :error -> + find_significant_position(document, line + inc_by, inc_by) + end + + :error -> + :error + end + end + + defp fetch_leading_whitespace_count(string, count \\ 0) + + defp fetch_leading_whitespace_count(<<" ", rest::binary>>, count) do + fetch_leading_whitespace_count(rest, count + 1) + end + + defp fetch_leading_whitespace_count(<<>>, _count), do: :error + defp fetch_leading_whitespace_count(<<"\n" <> _::binary>>, _count), do: :error + defp fetch_leading_whitespace_count(<<_non_whitespace::binary>>, count), do: {:ok, count} +end diff --git a/forge/lib/forge/ast/module.ex b/forge/lib/forge/ast/module.ex new file mode 100644 index 00000000..0a4ad54d --- /dev/null +++ b/forge/lib/forge/ast/module.ex @@ -0,0 +1,99 @@ +defmodule Forge.Ast.Module do + @moduledoc """ + Module utilities + """ + + @doc """ + Formats a module name as a string. + """ + @spec name(module() | Macro.t() | String.t()) :: String.t() + def name([{:__MODULE__, _, _} | rest]) do + [__MODULE__ | rest] + |> Module.concat() + |> name() + end + + def name(module_name) when is_list(module_name) do + module_name + |> Module.concat() + |> name() + end + + def name(module_name) when is_binary(module_name) do + module_name + end + + def name(module_name) when is_atom(module_name) do + module_name + |> inspect() + |> name() + end + + @doc """ + local module name is the last part of a module name + + ## Examples: + iex> local_name('Forge.Ast.Module') + "Module" + """ + def local_name(entity) when is_list(entity) do + entity + |> to_string() + |> local_name() + end + + def local_name(entity) when is_binary(entity) do + entity + |> String.split(".") + |> List.last() + end + + @doc """ + Splits a module into is parts, but handles erlang modules + + Module.split will explode violently when called on an erlang module. This + implementation will tell you which kind of module it has split, and return the + pieces. You can also use the options to determine if the pieces are returned as + strings or atoms + + Options: + `as` :atoms or :binaries. Default is :binary. Determines what type the elements + of the returned list are. + + Returns: + A tuple where the first element is either `:elixir` or `:erlang`, which tells you + the kind of module that has been split. The second element is a list of the + module's components. Note: Erlang modules will only ever have a single component. + """ + @type split_opt :: {:as, :binaries | :atoms} + @type split_opts :: [split_opt()] + @type split_return :: {:elixir | :erlang, [String.t()] | [atom()]} + + @spec safe_split(module()) :: split_return() + @spec safe_split(module(), split_opts()) :: split_return() + def safe_split(module, opts \\ []) + + def safe_split(module, opts) when is_atom(module) do + string_name = Atom.to_string(module) + + {type, split_module} = + case String.split(string_name, ".") do + ["Elixir" | rest] -> + {:elixir, rest} + + [_erlang_module] = module -> + {:erlang, module} + end + + split_module = + case Keyword.get(opts, :as, :binaries) do + :binaries -> + split_module + + :atoms -> + Enum.map(split_module, &String.to_atom/1) + end + + {type, split_module} + end +end diff --git a/forge/lib/forge/ast/range.ex b/forge/lib/forge/ast/range.ex new file mode 100644 index 00000000..e5190d4f --- /dev/null +++ b/forge/lib/forge/ast/range.ex @@ -0,0 +1,48 @@ +defmodule Forge.Ast.Range do + @moduledoc """ + Utilities for extracting ranges from ast nodes + """ + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + @spec fetch(Macro.t(), Document.t()) :: {:ok, Range.t()} | :error + def fetch(ast, %Document{} = document) do + case Sourceror.get_range(ast) do + %{start: start_pos, end: end_pos} -> + [line: start_line, column: start_column] = start_pos + [line: end_line, column: end_column] = end_pos + + range = + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, end_line, end_column) + ) + + {:ok, range} + + _ -> + :error + end + end + + @spec fetch!(Macro.t(), Document.t()) :: Range.t() + def fetch!(ast, %Document{} = document) do + case fetch(ast, document) do + {:ok, range} -> + range + + :error -> + raise ArgumentError, + message: "Could not get a range for #{inspect(ast)} in #{document.path}" + end + end + + @spec get(Macro.t(), Document.t()) :: Range.t() | nil + def get(ast, %Document{} = document) do + case fetch(ast, document) do + {:ok, range} -> range + :error -> nil + end + end +end diff --git a/forge/lib/forge/ast/tokens.ex b/forge/lib/forge/ast/tokens.ex new file mode 100644 index 00000000..125314f5 --- /dev/null +++ b/forge/lib/forge/ast/tokens.ex @@ -0,0 +1,169 @@ +defmodule Forge.Ast.Tokens do + alias Forge.Document + alias Forge.Document.Position + + @doc """ + Returns a stream of tokens starting at the given position and working backwards through + the document. + """ + def prefix_stream(%Document{} = document, %Position{} = position) do + init_function = fn -> + {~c"", position.line} + end + + next_function = fn + {_, 0} -> + {:halt, []} + + {current_context, line_number} -> + case find_and_tokenize(document, position, line_number, current_context) do + {:ok, tokens, new_context} -> + prev_line_number = line_number - 1 + + tokens = + if prev_line_number > 0 do + tokens ++ [:eol] + else + tokens + end + + {tokens, {new_context, prev_line_number}} + + :stop -> + {:halt, []} + end + end + + finalize_function = fn _ -> :ok end + + init_function + |> Stream.resource(next_function, finalize_function) + |> Stream.map(&normalize_token/1) + end + + defp find_and_tokenize( + %Document{} = document, + %Position{line: line_number} = position, + line_number, + context + ) do + document + |> prefix(position) + |> tokenize(line_number, context) + end + + defp find_and_tokenize(%Document{} = document, %Position{}, line_number, context) do + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> + tokenize(line_text, line_number, context) + + :error -> + :stop + end + end + + defp tokenize(line_text, line_number, context) do + line_charlist = String.to_charlist(line_text) + current_context = line_charlist ++ context + + case :future_elixir_tokenizer.tokenize(current_context, line_number, 1, []) do + {:ok, _, _, _, tokens, _} -> + {:ok, tokens, ~c""} + + {:error, {_, ~c"unexpected token: ", _}, _, _, _} -> + {:ok, [], ~c"\n" ++ current_context} + + {:error, _, _, _, tokens} -> + {:ok, tokens, ~c""} + end + end + + defp prefix(%Document{} = document, %Position{} = position) do + zero_based_character = position.character - 1 + {:ok, line_text} = Document.fetch_text_at(document, position.line) + String.slice(line_text, 0, zero_based_character) + end + + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + defp normalize_token(token) do + case token do + :eol -> + {:eol, ~c"\n", []} + + {:bin_string, context, [string_value]} -> + {:string, string_value, to_position(context)} + + {:bin_string, context, interpolated} -> + {:interpolated_string, interpolation_ranges(interpolated), to_position(context)} + + {:capture_op, context, value} -> + {:operator, value, to_position(context)} + + {:dual_op, context, value} -> + {:operator, value, to_position(context)} + + {:type_op, context, _value} -> + {:operator, :"::", to_position(context)} + + {:mult_op, context, operator} -> + {:operator, operator, to_position(context)} + + {:in_op, context, _} -> + {:operator, :in, to_position(context)} + + {:operator, context, value} -> + {:operator, value, to_position(context)} + + {:sigil, {line, column, _}, sigil_char, _sigil_context, _, _opts, delim} -> + # NOTE: should we need to return context too? + {:sigil, [sigil_char], {line, column}, delim} + + {type, {line, column, token_value}, _} -> + {normalize_type(type), token_value, {line, column}} + + {type, context, value} when is_atom(value) -> + {normalize_type(type), value, to_position(context)} + + {operator, context} -> + {map_operator(operator), operator, to_position(context)} + end + end + + defp to_position({line, column, _}) do + {line, column} + end + + defp map_operator(:"("), do: :paren + defp map_operator(:")"), do: :paren + defp map_operator(:"{"), do: :curly + defp map_operator(:"}"), do: :curly + defp map_operator(:","), do: :comma + defp map_operator(:%{}), do: :map_new + defp map_operator(:%), do: :percent + defp map_operator(_), do: :operator + + defp normalize_type(:flt), do: :float + defp normalize_type(:bin_string), do: :string + defp normalize_type(type), do: type + + defp interpolation_ranges(interpolations) do + {_, ranges} = + Enum.reduce(interpolations, {{1, 1}, []}, fn + literal, {{line, column}, acc} when is_binary(literal) -> + end_pos = {line, column + String.length(literal)} + range = {{line, column}, end_pos} + {end_pos, [{:literal, literal, range} | acc]} + + {_, {end_line, end_column, _}, interp}, {_, acc} -> + start_pos = get_start_pos(interp) + range = {start_pos, {end_line, end_column}} + {{end_line, end_column}, [{:interpolation, interp, range} | acc]} + end) + + Enum.reverse(ranges) + end + + defp get_start_pos([{_, {start_line, start_column, _}, _} | _]) do + {start_line, start_column} + end +end diff --git a/forge/lib/forge/code_action.ex b/forge/lib/forge/code_action.ex new file mode 100644 index 00000000..360941f2 --- /dev/null +++ b/forge/lib/forge/code_action.ex @@ -0,0 +1,62 @@ +defmodule Forge.CodeAction do + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range + alias Forge.CodeAction.Diagnostic + alias Forge.CodeAction.Handlers + + defstruct [:title, :kind, :changes, :uri] + + @type code_action_kind :: + :empty + | :quick_fix + | :refactor + | :refactor_extract + | :refactor_inline + | :refactor_rewrite + | :source + | :source_organize_imports + | :source_fix_all + + @type t :: %__MODULE__{ + title: String.t(), + kind: code_action_kind, + changes: Changes.t(), + uri: Forge.uri() + } + + @handlers [ + Handlers.ReplaceRemoteFunction, + Handlers.ReplaceWithUnderscore, + Handlers.OrganizeAliases, + Handlers.AddAlias, + Handlers.RemoveUnusedAlias + ] + + @spec new(Forge.uri(), String.t(), code_action_kind(), Changes.t()) :: t() + def new(uri, title, kind, changes) do + %__MODULE__{uri: uri, title: title, changes: changes, kind: kind} + end + + @spec for_range(Document.t(), Range.t(), [Diagnostic.t()], [code_action_kind] | :all) :: [t()] + def for_range(%Document{} = doc, %Range{} = range, diagnostics, kinds) do + results = + Enum.flat_map(@handlers, fn handler -> + if applies?(kinds, handler) do + handler.actions(doc, range, diagnostics) + else + [] + end + end) + + results + end + + defp applies?(:all, _handler_module) do + true + end + + defp applies?(kinds, handler_module) do + kinds -- handler_module.kinds() != kinds + end +end diff --git a/forge/lib/forge/code_action/diagnostic.ex b/forge/lib/forge/code_action/diagnostic.ex new file mode 100644 index 00000000..3a6a3d81 --- /dev/null +++ b/forge/lib/forge/code_action/diagnostic.ex @@ -0,0 +1,17 @@ +defmodule Forge.CodeAction.Diagnostic do + alias Forge.Document.Range + + defstruct [:range, :message, :source] + @type message :: String.t() + @type source :: String.t() + @type t :: %__MODULE__{ + range: Range.t(), + message: message() | nil, + source: source() | nil + } + + @spec new(Range.t(), message(), source() | nil) :: t + def new(%Range{} = range, message, source) do + %__MODULE__{range: range, message: message, source: source} + end +end diff --git a/forge/lib/forge/code_action/handler.ex b/forge/lib/forge/code_action/handler.ex new file mode 100644 index 00000000..610a857b --- /dev/null +++ b/forge/lib/forge/code_action/handler.ex @@ -0,0 +1,9 @@ +defmodule Forge.CodeAction.Handler do + alias Forge.Document + alias Forge.Document.Range + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic + + @callback actions(Document.t(), Range.t(), [Diagnostic.t()]) :: [CodeAction.t()] + @callback kinds() :: [CodeAction.code_action_kind()] +end diff --git a/forge/lib/forge/code_action/handlers/add_alias.ex b/forge/lib/forge/code_action/handlers/add_alias.ex new file mode 100644 index 00000000..dc7367e7 --- /dev/null +++ b/forge/lib/forge/code_action/handlers/add_alias.ex @@ -0,0 +1,210 @@ +defmodule Forge.CodeAction.Handlers.AddAlias do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Formats + + alias Forge.Analyzer + alias Forge.CodeAction + alias Forge.CodeIntelligence.Entity + alias Forge.CodeMod + alias Forge.Modules + alias Forge.Search.Fuzzy + alias Forge.Search.Indexer.Entry + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{} = range, _diagnostics) do + with {:ok, _doc, %Analysis{valid?: true} = analysis} <- + Document.Store.fetch(doc.uri, :analysis), + {:ok, resolved, _} <- Entity.resolve(analysis, range.start), + {:ok, unaliased_module} <- fetch_unaliased_module(analysis, range.start, resolved) do + current_aliases = CodeMod.Aliases.in_scope(analysis, range) + + unaliased_module + |> possible_aliases() + |> filter_by_resolution(resolved) + |> Stream.map(&build_code_action(analysis, range, current_aliases, &1)) + |> Enum.reject(&is_nil/1) + else + _ -> + [] + end + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + defp build_code_action(%Analysis{} = analysis, range, current_aliases, potential_alias_module) do + case Ast.Module.safe_split(potential_alias_module, as: :atoms) do + {:erlang, _} -> + nil + + {:elixir, segments} -> + {insert_position, trailer} = CodeMod.Aliases.insert_position(analysis, range.start) + alias_to_add = %Alias{module: segments, as: List.last(segments), explicit?: true} + replace_current_alias = get_current_replacement(analysis, range, segments) + + alias_edits = + CodeMod.Aliases.to_edits( + [alias_to_add | current_aliases], + insert_position, + trailer + ) + + changes = Changes.new(analysis.document, replace_current_alias ++ alias_edits) + + CodeAction.new( + analysis.document.uri, + "alias #{Formats.module(potential_alias_module)}", + :quick_fix, + changes + ) + end + end + + def fetch_unaliased_module(%Analysis{} = analysis, %Position{} = position, resolved) do + with {:ok, module} <- fetch_module(resolved), + %{} = aliases <- Analyzer.aliases_at(analysis, position), + false <- module in Map.values(aliases) do + {:ok, module} + else + _ -> + :error + end + end + + defp fetch_module({:module, module}), do: {:ok, module} + defp fetch_module({:struct, module}), do: {:ok, module} + defp fetch_module({:call, module, _function, _arity}), do: {:ok, module} + defp fetch_module(_), do: :error + + defp get_current_replacement(%Analysis{} = analysis, %Range{} = range, segments) do + with {:ok, patches} <- replace_full_module_on_line(analysis, range.start.line, segments), + {:ok, edits} <- Ast.patches_to_edits(analysis.document, patches) do + edits + else + _ -> + [] + end + end + + defp replace_full_module_on_line(%Analysis{} = analysis, line, segments) do + aliased_module = + segments + |> List.last() + |> List.wrap() + |> Module.concat() + |> Formats.module() + + analysis.document + |> Ast.traverse_line(line, [], fn + %Zipper{node: {:__aliases__, _, ^segments}} = zipper, patches -> + range = Sourceror.get_range(zipper.node) + + patch = %{range: range, change: aliased_module} + {zipper, [patch | patches]} + + zipper, acc -> + {zipper, acc} + end) + |> case do + {:ok, _, patches} -> {:ok, patches} + error -> error + end + end + + @similarity_threshold 0.75 + defp similar?(a, b), do: String.jaro_distance(a, b) >= @similarity_threshold + + defp filter_by_resolution(modules_stream, {:call, _module, function, _arity}) do + query_function = Atom.to_string(function) + + Stream.filter(modules_stream, fn module -> + case Modules.fetch_functions(module) do + {:ok, functions} -> + Enum.any?(functions, fn {name, _arity} -> + module_function = Atom.to_string(name) + similar?(module_function, query_function) + end) + + _ -> + false + end + end) + end + + defp filter_by_resolution(modules_stream, {:struct, _}) do + Stream.filter(modules_stream, fn module -> + case Modules.fetch_functions(module) do + {:ok, functions} -> Keyword.has_key?(functions, :__struct__) + _ -> false + end + end) + end + + defp filter_by_resolution(modules_stream, _) do + modules_stream + end + + def possible_aliases(unaliased_module) do + module_subject = Formats.module(unaliased_module) + + case Ast.Module.safe_split(unaliased_module) do + {:elixir, unaliased_strings} -> + module_subject + |> do_fuzzy_search() + |> Stream.filter(fn module -> + {:elixir, split} = Ast.Module.safe_split(module) + alias_as = List.last(split) + subject_module = module + Forge.Module.Loader.ensure_loaded(subject_module) + + protocol_or_implementation? = function_exported?(module, :__impl__, 1) + + not protocol_or_implementation? and + Enum.any?(unaliased_strings, &similar?(&1, alias_as)) + end) + + _ -> + [] + end + end + + defp do_fuzzy_search(subject) do + # Note: we can't use the indexer's fuzzy matcher here, since it + # ignores all deps, and then we won't be able to alias any deps module + + for {mod, _, _} <- all_modules(), + elixir_module?(mod), + not Namespace.Module.prefixed?(mod) do + module_name = List.to_atom(mod) + + %Entry{ + id: module_name, + path: "", + subject: module_name, + subtype: :definition, + type: :module + } + end + |> Fuzzy.from_entries() + |> Fuzzy.match(subject) + end + + defp all_modules do + # Note: this is for testing + :code.all_available() + end + + defp elixir_module?([?E, ?l, ?i, ?x, ?i, ?r, ?. | _]), do: true + defp elixir_module?(_), do: false +end diff --git a/forge/lib/forge/code_action/handlers/organize_aliases.ex b/forge/lib/forge/code_action/handlers/organize_aliases.ex new file mode 100644 index 00000000..579dd386 --- /dev/null +++ b/forge/lib/forge/code_action/handlers/organize_aliases.ex @@ -0,0 +1,45 @@ +defmodule Forge.CodeAction.Handlers.OrganizeAliases do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range + alias Forge.CodeAction + alias Forge.CodeMod + + require Logger + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{} = range, _diagnostics) do + with {:ok, _doc, analysis} <- Document.Store.fetch(doc.uri, :analysis), + :ok <- check_aliases(doc, analysis, range) do + aliases = CodeMod.Aliases.in_scope(analysis, range) + {insert_position, trailer} = CodeMod.Aliases.insert_position(analysis, range.start) + edits = CodeMod.Aliases.to_edits(aliases, insert_position, trailer) + + if Enum.empty?(edits) do + [] + else + changes = Changes.new(doc, edits) + [CodeAction.new(doc.uri, "Organize aliases", :source_organize_imports, changes)] + end + else + _ -> + [] + end + end + + @impl CodeAction.Handler + def kinds do + [:source, :source_organize_imports] + end + + defp check_aliases(%Document{}, %Analysis{} = analysis, %Range{} = range) do + case Analysis.module_scope(analysis, range) do + %Scope{aliases: [_ | _]} -> :ok + _ -> :error + end + end +end diff --git a/forge/lib/forge/code_action/handlers/remove_unused_alias.ex b/forge/lib/forge/code_action/handlers/remove_unused_alias.ex new file mode 100644 index 00000000..94a6554d --- /dev/null +++ b/forge/lib/forge/code_action/handlers/remove_unused_alias.ex @@ -0,0 +1,245 @@ +defmodule Forge.CodeAction.Handlers.RemoveUnusedAlias do + @moduledoc """ + A code action that removes an unused alias + + Most of the code actions are fairly straightforward, but I think this one deserves a couple of comments on + the approach. I initially tried the following: + + * Finding the alias via Sourceror's Zipper.find + * Rewriting the ast via Macro.prewalk / postwalk + * Using Macro.travesrse where I'd mark the metadata as being deleted in the prewalker, and + delete it in the postwalker. + + They had the following problems. + Sourceror would consistently produce ast that was not recognized by elixir 1.14's code normalizer, causing a crash. + Using AST rewriting was susceptible to infinite recursion, and it was extremely difficult to delete blocks reliably. + Blocks in one context would be deleted, but with a different formulation, nils would appear in the output code. + It was also very difficult to pop up the stack and delete an entire multiple alias without zippers. + + So the approach we have here utilizes a hybrid of AST walking / text replacement. It works for all the examples + I could come up with, but it's a bit longer than I desired. Dorgan said he'd take a look at the errors in the + normalizer and possibly fix sourceror, so until then, this is what we have. + """ + + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Analyzer + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic + alias Sourceror.Zipper + + import Record + + defrecordp :multi_alias_metadata, [ + :document, + :multi_alias_range, + :removed_alias_range, + :alias_count + ] + + defrecordp :single_alias_metadata, [:document, :range] + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = document, %Range{} = range, diagnostics) do + Enum.reduce(diagnostics, [], fn %Diagnostic{} = diagnostic, acc -> + case to_edit(document, range.start, diagnostic) do + {:ok, module_name, edit} -> + changes = Changes.new(document, [edit]) + action = CodeAction.new(document.uri, "Remove alias #{module_name}", :source, changes) + + [action | acc] + + _ -> + acc + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:source] + end + + defp to_edit(%Document{} = document, %Position{} = position, %Diagnostic{} = diagnostic) do + with {:ok, module_string} <- fetch_unused_alias_module_string(diagnostic), + {:ok, _doc, %Analysis{} = analysis} <- Document.Store.fetch(document.uri, :analysis), + last_segment = String.to_atom(module_string), + {:ok, full_alias} <- fetch_full_alias(analysis, position, last_segment), + {:ok, alias_meta} <- fetch_alias_metadata(position, analysis, full_alias, last_segment), + {:ok, edit} <- fetch_edit(alias_meta) do + {:ok, module_string, edit} + else + _ -> + :error + end + end + + @alias_regex ~r/unused alias (\w+)/ + defp fetch_unused_alias_module_string(%Diagnostic{} = diagnostic) do + case Regex.scan(@alias_regex, diagnostic.message) do + [[_, module_string]] -> {:ok, module_string} + _ -> :error + end + end + + defp fetch_alias_metadata( + %Position{} = cursor, + %Analysis{} = analysis, + full_alias, + last_segment + ) do + zipper = Zipper.zip(analysis.ast) + document = analysis.document + + with :error <- find_single_alias(document, cursor, zipper, full_alias, last_segment) do + find_multi_alias(document, cursor, zipper, last_segment) + end + end + + defp find_single_alias( + %Document{} = document, + %Position{} = cursor, + %Zipper{} = zipper, + full_alias, + last_segment + ) do + finder = fn + {:alias, _, [{:__aliases__, _, ^full_alias}]} = node -> + Ast.contains_position?(node, cursor) + + {:alias, _, + [ + {:__aliases__, _, ^full_alias}, + [{{:__block__, _, [:as]}, {:__aliases__, _, [^last_segment]}}] + ]} = node -> + Ast.contains_position?(node, cursor) + + _ -> + false + end + + case Zipper.find(zipper, finder) do + nil -> + :error + + %Zipper{node: node} -> + metadata = + single_alias_metadata(document: document, range: Ast.Range.fetch!(node, document)) + + {:ok, metadata} + end + end + + defp find_multi_alias( + %Document{} = document, + %Position{} = cursor, + %Zipper{} = zipper, + last_segment + ) do + finder = fn + {:alias, _, [{{:., _, _}, _, multi_alias_list}]} = node -> + Enum.find_value(multi_alias_list, &segment_matches?(&1, last_segment)) and + Ast.contains_position?(node, cursor) + + _ -> + false + end + + case Zipper.find(zipper, finder) do + nil -> + :error + + %Zipper{node: {:alias, _, [{{:., _, _}, _, multi_alias_list}]}} = zipper -> + alias_node = Enum.find(multi_alias_list, &segment_matches?(&1, last_segment)) + + multi_alias = + multi_alias_metadata( + document: document, + multi_alias_range: Ast.Range.fetch!(zipper.node, document), + removed_alias_range: Ast.Range.fetch!(alias_node, document), + alias_count: length(multi_alias_list) + ) + + {:ok, multi_alias} + end + end + + defp fetch_full_alias(%Analysis{} = analysis, %Position{} = position, last_segment) do + aliases = Analyzer.aliases_at(analysis, position) + + with {:ok, aliased_module} <- Map.fetch(aliases, last_segment), + {:elixir, full_alias} <- Ast.Module.safe_split(aliased_module, as: :atoms) do + {:ok, full_alias} + end + end + + defp segment_matches?({:__aliases__, _, segments}, last_segment) do + List.last(segments) == last_segment + end + + defp segment_matches?(_, _), do: false + + defp fetch_edit(single_alias_metadata(range: %Range{} = range)) do + updated_range = + range + |> put_in([:start, :character], 1) + |> include_next_line() + + {:ok, Edit.new("", updated_range)} + end + + defp fetch_edit(multi_alias_metadata(alias_count: 1, multi_alias_range: range)) do + # we're removing the last alias, so we can remove the entire thing. + {:ok, Edit.new("", range)} + end + + defp fetch_edit( + multi_alias_metadata( + document: %Document{} = document, + removed_alias_range: %Range{} = range + ) + ) do + current_line = line_text(document, range.start.line) + previous_line = line_text(document, range.start.line - 1) + + {range, edit_text} = + if not String.ends_with?(current_line, ",") and String.ends_with?(previous_line, ",") do + # delete the previous line's comma + range = %Range{ + range + | start: Position.new(document, range.start.line - 1, String.length(previous_line)) + } + + {range, "\n"} + else + {put_in(range.start.character, 1), ""} + end + + {:ok, Edit.new(edit_text, include_next_line(range))} + end + + defp fetch_edit(_), do: :error + + defp line_text(%Document{} = document, line_number) do + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> line_text + _ -> "" + end + end + + defp include_next_line(%Range{} = range) do + update_in(range.end, fn old_position -> + %Position{ + old_position + | line: old_position.line + 1, + character: 1 + } + end) + end +end diff --git a/forge/lib/forge/code_action/handlers/replace_remote_function.ex b/forge/lib/forge/code_action/handlers/replace_remote_function.ex new file mode 100644 index 00000000..356a6879 --- /dev/null +++ b/forge/lib/forge/code_action/handlers/replace_remote_function.ex @@ -0,0 +1,146 @@ +defmodule Forge.CodeAction.Handlers.ReplaceRemoteFunction do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Edit + alias Forge.Document.Range + + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic + alias Forge.Modules + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{}, diagnostics) do + Enum.flat_map(diagnostics, fn %Diagnostic{} = diagnostic -> + with {:ok, module, function, arity, line_number} <- extract_function_and_line(diagnostic), + {:ok, suggestions} <- prepare_suggestions(module, function, arity) do + to_code_actions(doc, line_number, module, function, suggestions) + else + _ -> + [] + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + @spec to_code_actions(Document.t(), non_neg_integer(), module(), String.t(), [atom()]) :: + [CodeAction.t()] + defp to_code_actions(%Document{} = doc, line_number, module, function, suggestions) do + suggestions + |> Enum.reduce([], fn suggestion, acc -> + case apply_transform(doc, line_number, module, function, suggestion) do + {:ok, edits} -> + changes = Changes.new(doc, edits) + code_action = CodeAction.new(doc.uri, "Rename to #{suggestion}", :quick_fix, changes) + + [code_action | acc] + + :error -> + acc + end + end) + |> Enum.reverse() + end + + @spec apply_transform(Document.t(), non_neg_integer(), module(), String.t(), atom()) :: + {:ok, [Edit.t()]} | :error + defp apply_transform(%Document{} = doc, line_number, module, function, suggestion) do + {:ok, doc, analysis} = Document.Store.fetch(doc.uri, :analysis) + function_atom = String.to_atom(function) + position = Document.Position.new(doc, line_number, 0) + + doc + |> Ast.traverse_line(line_number, [], fn + %Zipper{node: {{:., _, [{:__aliases__, _, module_alias}, ^function_atom]}, _, _}} = zipper, + patches -> + case Forge.Analyzer.expand_alias(module_alias, analysis, position) do + {:ok, ^module} -> + patch = Sourceror.Patch.rename_call(zipper.node, suggestion) + {zipper, [patch | patches]} + + _ -> + {zipper, patches} + end + + %Zipper{node: {{:., _, [{:__block__, _, [^module]}, ^function_atom]}, _, _}} = zipper, + patches -> + # this is an erlang call :ets.insert(...) + patch = Sourceror.Patch.rename_call(zipper.node, suggestion) + + {zipper, [patch | patches]} + + zipper, patches -> + {zipper, patches} + end) + |> case do + {:ok, _zipper, patches} -> + Ast.patches_to_edits(doc, patches) + + _ -> + :error + end + end + + defp extract_function_and_line(%Diagnostic{} = diagnostic) do + with {:ok, module, function, arity} <- extract_function(diagnostic.message) do + {:ok, module, function, arity, diagnostic.range.start.line} + end + end + + @function_re ~r/(warning: |function )?([^\/]+)\/(.*) is undefined or private. Did you mean:.*/ + defp extract_function(message) do + result = + with [[_, _, module_and_function, arity]] <- Regex.scan(@function_re, message), + {:ok, module, function_name} <- separate_module_from_function(module_and_function) do + {:ok, module, function_name, String.to_integer(arity)} + end + + result + end + + defp separate_module_from_function(module_and_function) do + module_and_function + |> String.split(".") + |> List.pop_at(-1) + |> case do + {function_name, [_ | _] = module_alias} -> + {:ok, alias_to_module(module_alias), function_name} + + _ -> + :error + end + end + + defp alias_to_module([":" <> erlang_alias]) do + String.to_atom(erlang_alias) + end + + defp alias_to_module(module_alias) do + Module.concat(module_alias) + end + + @function_threshold 0.77 + @max_suggestions 5 + defp prepare_suggestions(module, function, arity) do + with {:ok, module_functions} <- Modules.fetch_functions(module) do + suggestions = + for {module_function, ^arity} <- module_functions, + distance = module_function |> Atom.to_string() |> String.jaro_distance(function), + distance >= @function_threshold do + {distance, module_function} + end + |> Enum.sort(:desc) + |> Enum.take(@max_suggestions) + |> Enum.map(fn {_distance, module_function} -> module_function end) + + {:ok, suggestions} + end + end +end diff --git a/forge/lib/forge/code_action/handlers/replace_with_underscore.ex b/forge/lib/forge/code_action/handlers/replace_with_underscore.ex new file mode 100644 index 00000000..54692462 --- /dev/null +++ b/forge/lib/forge/code_action/handlers/replace_with_underscore.ex @@ -0,0 +1,83 @@ +defmodule Forge.CodeAction.Handlers.ReplaceWithUnderscore do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{}, diagnostics) do + Enum.reduce(diagnostics, [], fn %Diagnostic{} = diagnostic, acc -> + with {:ok, variable_name, line_number} <- extract_variable_and_line(diagnostic), + {:ok, changes} <- to_changes(doc, line_number, variable_name) do + action = CodeAction.new(doc.uri, "Rename to _#{variable_name}", :quick_fix, changes) + + [action | acc] + else + _ -> + acc + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + @spec to_changes(Document.t(), non_neg_integer(), String.t() | atom) :: + {:ok, Changes.t()} | :error + defp to_changes(%Document{} = document, line_number, variable_name) do + case apply_transform(document, line_number, variable_name) do + {:ok, edits} -> + {:ok, Changes.new(document, edits)} + + error -> + error + end + end + + defp apply_transform(document, line_number, unused_variable_name) do + underscored_variable_name = :"_#{unused_variable_name}" + + result = + Ast.traverse_line(document, line_number, [], fn + %Zipper{node: {^unused_variable_name, _meta, nil} = node} = zipper, patches -> + patch = Sourceror.Patch.rename_identifier(node, underscored_variable_name) + {zipper, [patch | patches]} + + zipper, acc -> + {zipper, acc} + end) + + with {:ok, _, patches} <- result do + Ast.patches_to_edits(document, patches) + end + end + + defp extract_variable_and_line(%Diagnostic{} = diagnostic) do + with {:ok, variable_name} <- extract_variable_name(diagnostic.message), + {:ok, line} <- extract_line(diagnostic) do + {:ok, variable_name, line} + end + end + + @variable_re ~r/variable "([^"]+)" is unused/ + defp extract_variable_name(message) do + case Regex.scan(@variable_re, message) do + [[_, variable_name]] -> + {:ok, String.to_atom(variable_name)} + + _ -> + {:error, {:no_variable, message}} + end + end + + defp extract_line(%Diagnostic{} = diagnostic) do + {:ok, diagnostic.range.start.line} + end +end diff --git a/forge/lib/forge/code_intelligence/definition.ex b/forge/lib/forge/code_intelligence/definition.ex new file mode 100644 index 00000000..59e1d3cc --- /dev/null +++ b/forge/lib/forge/code_intelligence/definition.ex @@ -0,0 +1,183 @@ +defmodule Forge.CodeIntelligence.Definition do + alias ElixirSense.Providers.Location, as: ElixirSenseLocation + alias Future.Code + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Location + alias Forge.Document.Position + alias Forge.Formats + alias Forge.CodeIntelligence.Entity + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store + alias Forge.Text + + require Logger + + @spec definition(Document.t(), Position.t()) :: {:ok, [Location.t()]} | {:error, String.t()} + def definition(%Document{} = document, %Position{} = position) do + with {:ok, _, analysis} <- Document.Store.fetch(document.uri, :analysis), + {:ok, entity, _range} <- Entity.resolve(analysis, position) do + fetch_definition(entity, analysis, position) + end + end + + defp fetch_definition({type, entity} = resolved, %Analysis{} = analysis, %Position{} = position) + when type in [:struct, :module] do + module = Formats.module(entity) + + locations = + case Store.exact(module, type: type, subtype: :definition) do + {:ok, entries} -> + for entry <- entries, + result = to_location(entry), + match?({:ok, _}, result) do + {:ok, location} = result + location + end + + _ -> + [] + end + + maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) + end + + defp fetch_definition( + {:call, module, function, arity} = resolved, + %Analysis{} = analysis, + %Position{} = position + ) do + mfa = Formats.mfa(module, function, arity) + + definitions = + mfa + |> query_search_index(subtype: :definition) + |> Stream.flat_map(fn entry -> + case entry do + %Entry{type: {:function, :delegate}} -> + mfa = get_in(entry, [:metadata, :original_mfa]) + query_search_index(mfa, subtype: :definition) ++ [entry] + + _ -> + [entry] + end + end) + |> Stream.uniq_by(& &1.subject) + + locations = + for entry <- definitions, + result = to_location(entry), + match?({:ok, _}, result) do + {:ok, location} = result + location + end + + maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) + end + + defp fetch_definition(_, %Analysis{} = analysis, %Position{} = position) do + elixir_sense_definition(analysis, position) + end + + defp maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) do + case locations do + [] -> + Logger.info("No definition found for #{inspect(resolved)} with Indexer.") + + elixir_sense_definition(analysis, position) + + [location] -> + {:ok, location} + + _ -> + {:ok, locations} + end + end + + defp elixir_sense_definition(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Document.to_string() + |> ElixirSense.definition(position.line, position.character) + |> parse_location(analysis.document) + end + + defp parse_location(%ElixirSenseLocation{} = location, document) do + %{file: file, line: line, column: column, type: type} = location + file_path = file || document.path + uri = Document.Path.ensure_uri(file_path) + + with {:ok, document} <- Document.Store.open_temporary(uri), + {:ok, text} <- Document.fetch_text_at(document, line) do + {line, column} = maybe_move_cursor_to_next_token(type, document, line, column) + range = to_precise_range(document, text, line, column) + {:ok, Location.new(range, document)} + else + _ -> + {:error, "Could not open source file or fetch line text: #{inspect(file_path)}"} + end + end + + defp parse_location(nil, _) do + {:ok, nil} + end + + defp maybe_move_cursor_to_next_token(type, document, line, column) + when type in [:function, :module, :macro] do + position = Position.new(document, line, column) + + with {:ok, zipper} <- Ast.zipper_at(document, position), + %{node: {entity_name, meta, _}} <- Sourceror.Zipper.next(zipper) do + meta = + if entity_name == :when do + %{node: {_entity_name, meta, _}} = Sourceror.Zipper.next(zipper) + meta + else + meta + end + + {meta[:line], meta[:column]} + else + _ -> + {line, column} + end + end + + defp maybe_move_cursor_to_next_token(_, _, line, column), do: {line, column} + + defp to_precise_range(%Document{} = document, text, line, column) do + case Code.Fragment.surround_context(text, {line, column}) do + %{begin: start_pos, end: end_pos} -> + Entity.to_range(document, start_pos, end_pos) + + _ -> + # If the column is 1, but the code doesn't start on the first column, which isn't what we want. + # The cursor will be placed to the left of the actual definition. + column = if column == 1, do: Text.count_leading_spaces(text) + 1, else: column + pos = {line, column} + Entity.to_range(document, pos, pos) + end + end + + defp to_location(entry) do + uri = Document.Path.ensure_uri(entry.path) + + case Document.Store.open_temporary(uri) do + {:ok, document} -> + {:ok, Location.new(entry.range, document)} + + _ -> + :error + end + end + + defp query_search_index(subject, condition) do + case Store.exact(subject, condition) do + {:ok, entries} -> + entries + + _ -> + [] + end + end +end diff --git a/forge/lib/forge/code_intelligence/docs.ex b/forge/lib/forge/code_intelligence/docs.ex new file mode 100644 index 00000000..208d091d --- /dev/null +++ b/forge/lib/forge/code_intelligence/docs.ex @@ -0,0 +1,96 @@ +defmodule Forge.CodeIntelligence.Docs do + @moduledoc """ + Utilities for fetching documentation for a compiled module. + """ + + alias Forge.CodeIntelligence.Docs.Entry + alias Forge.Modules + + defstruct [:module, :doc, functions_and_macros: [], callbacks: [], types: []] + + @type t :: %__MODULE__{ + module: module(), + doc: Entry.content(), + functions_and_macros: %{optional(atom()) => [Entry.t(:function | :macro)]}, + callbacks: %{optional(atom()) => [Entry.t(:callback)]}, + types: %{optional(atom()) => [Entry.t(:type)]} + } + + @doc """ + Fetches known documentation for the given module. + + ## Options + + * `:exclude_hidden` - if `true`, returns `{:error, :hidden}` for + modules that have been marked as hidden using `@moduledoc false`. + Defaults to `false`. + + """ + @spec for_module(module(), [opt]) :: {:ok, t} | {:error, any()} + when opt: {:exclude_hidden, boolean()} + def for_module(module, opts) when is_atom(module) do + exclude_hidden? = Keyword.get(opts, :exclude_hidden, false) + + with {:ok, beam} <- Modules.ensure_beam(module), + {:ok, docs} <- parse_docs(module, beam) do + if docs.doc == :hidden and exclude_hidden? do + {:error, :hidden} + else + {:ok, docs} + end + end + end + + defp parse_docs(module, beam) do + case Modules.fetch_docs(beam) do + {:ok, {:docs_v1, _anno, _lang, _format, module_doc, _meta, entries}} -> + entries_by_kind = Enum.group_by(entries, &doc_kind/1) + function_entries = Map.get(entries_by_kind, :function, []) + macro_entries = Map.get(entries_by_kind, :macro, []) + callback_entries = Map.get(entries_by_kind, :callback, []) + type_entries = Map.get(entries_by_kind, :type, []) + + spec_defs = beam |> Modules.fetch_specs() |> ok_or([]) + callback_defs = beam |> Modules.fetch_callbacks() |> ok_or([]) + type_defs = beam |> Modules.fetch_types() |> ok_or([]) + + result = %__MODULE__{ + module: module, + doc: Entry.parse_doc(module_doc), + functions_and_macros: + parse_entries(module, function_entries ++ macro_entries, spec_defs), + callbacks: parse_entries(module, callback_entries, callback_defs), + types: parse_entries(module, type_entries, type_defs) + } + + {:ok, result} + + _ -> + {:error, :no_docs} + end + end + + defp doc_kind({{kind, _name, _arity}, _anno, _sig, _doc, _meta}) do + kind + end + + defp parse_entries(module, raw_entries, defs) do + defs_by_name_arity = + Enum.group_by( + defs, + fn {name, arity, _formatted, _quoted} -> {name, arity} end, + fn {_name, _arity, formatted, _quoted} -> formatted end + ) + + raw_entries + |> Enum.map(fn raw_entry -> + entry = Entry.from_docs_v1(module, raw_entry) + defs = Map.get(defs_by_name_arity, {entry.name, entry.arity}, []) + %Entry{entry | defs: defs} + end) + |> Enum.group_by(& &1.name) + end + + defp ok_or({:ok, value}, _default), do: value + defp ok_or(_, default), do: default +end diff --git a/forge/lib/forge/code_intelligence/docs/entry.ex b/forge/lib/forge/code_intelligence/docs/entry.ex new file mode 100644 index 00000000..420788dc --- /dev/null +++ b/forge/lib/forge/code_intelligence/docs/entry.ex @@ -0,0 +1,56 @@ +defmodule Forge.CodeIntelligence.Docs.Entry do + @moduledoc """ + A documentation entry for a named entity within a module. + """ + + defstruct [ + :module, + :kind, + :name, + :arity, + :signature, + :doc, + :metadata, + defs: [] + ] + + @type t(kind) :: %__MODULE__{ + module: module(), + kind: kind, + name: atom(), + arity: arity(), + signature: [String.t()], + doc: content(), + metadata: metadata(), + defs: [String.t()] + } + + @type content :: String.t() | :none | :hidden + + @type metadata :: %{ + optional(:defaults) => pos_integer(), + optional(:since) => String.t(), + optional(:guard) => boolean(), + optional(:opaque) => boolean(), + optional(:deprecated) => boolean() + } + + @known_metadata [:defaults, :since, :guard, :opaque, :deprecated] + + @doc false + def from_docs_v1(module, {{kind, name, arity}, _anno, signature, doc, meta}) do + %__MODULE__{ + module: module, + kind: kind, + name: name, + arity: arity, + signature: signature, + doc: parse_doc(doc), + metadata: Map.take(meta, @known_metadata) + } + end + + @doc false + def parse_doc(%{"en" => doc}), do: doc + def parse_doc(atom) when atom in [:none, :hidden], do: atom +end diff --git a/forge/lib/forge/code_intelligence/entity.ex b/forge/lib/forge/code_intelligence/entity.ex new file mode 100644 index 00000000..9be5d3af --- /dev/null +++ b/forge/lib/forge/code_intelligence/entity.ex @@ -0,0 +1,539 @@ +defmodule Forge.CodeIntelligence.Entity do + alias Future.Code, as: Code + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Formats + + alias Sourceror.Zipper + + require Logger + require Sourceror.Identifier + + @type maybe_module :: module() | nil + @type resolved :: + {:module, maybe_module()} + | {:struct, maybe_module()} + | {:call, maybe_module(), fun_name :: atom(), arity :: non_neg_integer()} + | {:type, maybe_module(), type_name :: atom(), arity :: non_neg_integer()} + | {:module_attribute, container_module :: maybe_module(), attribute_name :: atom()} + | {:variable, variable_name :: atom()} + + defguardp is_call(form) when Sourceror.Identifier.is_call(form) and elem(form, 0) != :. + + @doc """ + Attempts to resolve the entity at the given position in the document. + + Returns `{:ok, resolved, range}` if successful, `{:error, error}` otherwise. + """ + @spec resolve(Analysis.t(), Position.t()) :: {:ok, resolved, Range.t()} | {:error, term()} + def resolve(%Analysis{} = analysis, %Position{} = position) do + analysis = Ast.reanalyze_to(analysis, position) + + with :ok <- check_commented(analysis, position), + {:ok, surround_context} <- Ast.surround_context(analysis, position), + {:ok, resolved, {begin_pos, end_pos}} <- + resolve(surround_context, analysis, position) do + Logger.info("Resolved entity: #{inspect(resolved)}") + {:ok, resolved, to_range(analysis.document, begin_pos, end_pos)} + else + :error -> {:error, :not_found} + {:error, :surround_context} -> maybe_local_capture_func(analysis, position) + {:error, _} = error -> error + end + end + + @spec to_range(Document.t(), Code.position(), Code.position()) :: Range.t() + def to_range(%Document{} = document, {begin_line, begin_column}, {end_line, end_column}) do + Range.new( + Position.new(document, begin_line, begin_column), + Position.new(document, end_line, end_column) + ) + end + + defp check_commented(%Analysis{} = analysis, %Position{} = position) do + if Analysis.commented?(analysis, position) do + :error + else + :ok + end + end + + defp resolve(%{context: context, begin: begin_pos, end: end_pos}, analysis, position) do + resolve(context, {begin_pos, end_pos}, analysis, position) + end + + defp resolve({:alias, charlist}, node_range, analysis, position) do + resolve_alias(charlist, node_range, analysis, position) + end + + defp resolve({:alias, {:local_or_var, prefix}, charlist}, node_range, analysis, position) do + resolve_alias(prefix ++ [?.] ++ charlist, node_range, analysis, position) + end + + defp resolve({:local_or_var, ~c"__MODULE__" = chars}, node_range, analysis, position) do + resolve_alias(chars, node_range, analysis, position) + end + + defp resolve({:local_or_var, chars}, node_range, analysis, position) do + maybe_fun = List.to_atom(chars) + + case Ast.path_at(analysis, position) do + {:ok, [{^maybe_fun, _, nil} = local, {def, _, [local | _]} | _]} + when def in [:def, :defp, :defmacro, :defmacrop] -> + # This case handles resolving calls that come from zero-arg definitions in + # a module, like hovering in `def my_fun| do` + {:ok, module} = Forge.Analyzer.current_module(analysis, position) + {:ok, {:call, module, maybe_fun, 0}, node_range} + + {:ok, [{^maybe_fun, _, args} | _]} -> + # imported functions + arity = + case args do + arg_list when is_list(arg_list) -> length(arg_list) + _ -> 0 + end + + case fetch_module_for_function(analysis, position, maybe_fun, arity) do + {:ok, module} -> {:ok, {:call, module, maybe_fun, arity}, node_range} + _ -> {:ok, {:variable, List.to_atom(chars)}, node_range} + end + + _ -> + {:ok, {:variable, List.to_atom(chars)}, node_range} + end + end + + defp resolve({:local_arity, chars}, node_range, analysis, position) do + current_module = current_module(analysis, position) + + with {:ok, %Zipper{node: {:/, _, [_, {:__block__, _, [arity]}]}} = zipper} <- + Ast.zipper_at(analysis.document, position), + true <- inside_capture?(zipper) do + {:ok, {:call, current_module, List.to_atom(chars), arity}, node_range} + else + _ -> + {:error, :not_found} + end + end + + defp resolve({:struct, charlist}, {{start_line, start_col}, end_pos}, analysis, position) do + # exclude the leading % from the node range so that it can be + # resolved like a normal module alias + node_range = {{start_line, start_col + 1}, end_pos} + + case resolve_alias(charlist, node_range, analysis, position) do + {:ok, {struct_or_module, struct}, range} -> {:ok, {struct_or_module, struct}, range} + :error -> {:error, :not_found} + end + end + + defp resolve({:dot, alias_node, fun_chars}, node_range, analysis, position) do + fun = List.to_atom(fun_chars) + + with {:ok, module} <- expand_alias(alias_node, analysis, position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + arity = arity_at_position(path, position) + kind = kind_of_call(path, position) + {:ok, {kind, module, fun, arity}, node_range} + + _ -> + {:ok, {:call, module, fun, 0}, node_range} + end + end + end + + defp resolve({:local_call, fun_chars}, node_range, analysis, position) do + fun = List.to_atom(fun_chars) + + with {:ok, path} <- Ast.path_at(analysis, position), + arity = arity_at_position(path, position), + {module, ^fun, ^arity} <- + Forge.Analyzer.resolve_local_call(analysis, position, fun, arity) do + {:ok, {:call, module, fun, arity}, node_range} + else + _ -> + module = current_module(analysis, position) + {:ok, {:call, module, fun, 0}, node_range} + end + end + + defp resolve({:unquoted_atom, _} = context, node_range, analysis, position) do + case expand_alias(context, analysis, position) do + {:ok, module} -> {:ok, {:module, module}, node_range} + _ -> {:error, {:unsupported, context}} + end + end + + defp resolve({:module_attribute, attr_name}, node_range, analysis, position) do + current_module = current_module(analysis, position) + + {:ok, {:module_attribute, current_module, List.to_atom(attr_name)}, node_range} + end + + defp resolve(context, _node_range, _analysis, _position) do + {:error, {:unsupported, context}} + end + + defp resolve_alias(charlist, node_range, analysis, position) do + {{_line, start_column}, _} = node_range + + with false <- suffix_contains_module?(charlist, start_column, position), + {:ok, path} <- Ast.path_at(analysis, position), + :struct <- kind_of_alias(path) do + resolve_struct(charlist, node_range, analysis, position) + else + _ -> + resolve_module(charlist, node_range, analysis, position) + end + end + + defp resolve_struct(charlist, node_range, analysis, %Position{} = position) do + with {:ok, struct} <- expand_alias(charlist, analysis, position) do + {:ok, {:struct, struct}, node_range} + end + end + + # Modules on a single line, e.g. "Foo.Bar.Baz" + defp resolve_module(charlist, {{line, column}, {line, _}}, analysis, %Position{} = position) do + module_before_cursor = module_before_position(charlist, column, position) + + maybe_prepended = + module_before_cursor + |> maybe_prepend_phoenix_scope_module(analysis, position) + |> maybe_prepend_ecto_schema(analysis, position) + + with {:ok, module} <- expand_alias(maybe_prepended, analysis, position) do + end_column = column + String.length(module_before_cursor) + {:ok, {:module, module}, {{line, column}, {line, end_column}}} + end + end + + # Modules on multiple lines, e.g. "Foo.\n Bar.\n Baz" + # Since we no longer have formatting information at this point, we + # just return the entire module for now. + defp resolve_module(charlist, node_range, analysis, %Position{} = position) do + with {:ok, module} <- expand_alias(charlist, analysis, position) do + {:ok, {:module, module}, node_range} + end + end + + defp maybe_prepend_ecto_schema(module_string, %Analysis{} = analysis, %Position{} = position) do + with true <- Ecto.Schema in Forge.Analyzer.uses_at(analysis, position), + true <- in_inline_embed?(analysis, position), + {:ok, parent_module} <- Forge.Analyzer.current_module(analysis, position) do + parent_module + |> Module.concat(module_string) + |> Formats.module() + else + _ -> + module_string + end + end + + @embeds [:embeds_one, :embeds_many] + defp in_inline_embed?(%Analysis{} = analysis, %Position{} = position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + path + |> Zipper.zip() + |> Zipper.find(fn + {embed, meta, _} when embed in @embeds -> + Keyword.has_key?(meta, :do) + + _ -> + false + end) + |> then(&match?(%Zipper{}, &1)) + end + end + + defp maybe_prepend_phoenix_scope_module(module_string, analysis, position) do + with {:ok, scope_segments} <- fetch_phoenix_scope_alias_segments(analysis, position), + {:ok, scope_module} <- + Forge.Analyzer.expand_alias(scope_segments, analysis, position), + cursor_module = Module.concat(scope_module, module_string), + true <- + phoenix_controller_module?(cursor_module) or phoenix_liveview_module?(cursor_module) do + Formats.module(cursor_module) + else + _ -> + module_string + end + end + + defp fetch_phoenix_scope_alias_segments(analysis, position) do + # fetch the alias segments from the `scope` macro + # e.g. `scope "/foo", FooWeb.Controllers` + # the alias module is `FooWeb.Controllers`, and the segments is `[:FooWeb, :Controllers]` + path = + analysis + |> Ast.cursor_path(position) + |> Enum.filter(&match?({:scope, _, [_ | _]}, &1)) + # There might be nested `scope` macros, we need the immediate ancestor + |> List.last() + + if path do + {_, paths} = + path + |> Zipper.zip() + |> Zipper.traverse([], fn + %Zipper{node: {:scope, _, [_, {:__aliases__, _, segments} | _]}} = zipper, acc -> + {zipper, [segments | acc]} + + zipper, acc -> + {zipper, acc} + end) + + {:ok, paths |> Enum.reverse() |> List.flatten()} + else + :error + end + end + + defp phoenix_controller_module?(module) do + function_exists?(module, :call, 2) and function_exists?(module, :action, 2) + end + + defp phoenix_liveview_module?(module) do + function_exists?(module, :mount, 3) and function_exists?(module, :render, 1) + end + + # Take only the segments at and before the cursor, e.g. + # Foo|.Bar.Baz -> Foo + # Foo.|Bar.Baz -> Foo.Bar + defp module_before_position(charlist, start_column, %Position{} = position) + when is_list(charlist) do + charlist + |> List.to_string() + |> module_before_position(position.character - start_column) + end + + defp module_before_position(string, index) when is_binary(string) do + {prefix, suffix} = String.split_at(string, index) + + case String.split(suffix, ".", parts: 2) do + [before_dot, _after_dot] -> prefix <> before_dot + [before_dot] -> prefix <> before_dot + end + end + + # %TopLevel|.Struct{} -> true + # %TopLevel.Str|uct{} -> false + defp suffix_contains_module?(charlist, start_column, %Position{} = position) do + charlist + |> List.to_string() + |> suffix_contains_module?(position.character - start_column) + end + + defp suffix_contains_module?(string, index) when is_binary(string) do + {_, suffix} = String.split_at(string, index) + + case String.split(suffix, ".", parts: 2) do + [_before_dot, after_dot] -> + uppercase?(after_dot) + + [_before_dot] -> + false + end + end + + defp uppercase?(after_dot) when is_binary(after_dot) do + first_char = String.at(after_dot, 0) + String.upcase(first_char) == first_char + end + + defp expand_alias({:alias, {:local_or_var, prefix}, charlist}, analysis, %Position{} = position) do + expand_alias(prefix ++ [?.] ++ charlist, analysis, position) + end + + defp expand_alias({:alias, charlist}, analysis, %Position{} = position) do + expand_alias(charlist, analysis, position) + end + + defp expand_alias({:unquoted_atom, maybe_module_charlist}, _analysis, _position) do + maybe_module = List.to_existing_atom(maybe_module_charlist) + + if function_exported?(maybe_module, :module_info, 1) do + {:ok, maybe_module} + else + :error + end + rescue + ArgumentError -> + :error + end + + defp expand_alias(charlist, analysis, %Position{} = position) when is_list(charlist) do + charlist + |> List.to_string() + |> expand_alias(analysis, position) + end + + defp expand_alias(module, analysis, %Position{} = position) when is_binary(module) do + [module] + |> Module.concat() + |> Forge.Analyzer.expand_alias(analysis, position) + end + + defp expand_alias(_, _analysis, _position), do: :error + + # Pipes: + defp arity_at_position([{:|>, _, _} = pipe | _], %Position{} = position) do + {_call, _, args} = + pipe + |> Macro.unpipe() + |> Enum.find_value(fn {ast, _arg_position} -> + if Ast.contains_position?(ast, position) do + ast + end + end) + + length(args) + 1 + end + + # Calls inside of a pipe: + # |> MyModule.some_function(1, 2) + defp arity_at_position([{_, _, args} = call, {:|>, _, _} | _], _position) when is_call(call) do + length(args) + 1 + end + + # Calls as part of a capture: + # &MyModule.some_function/2 + defp arity_at_position( + [ + # To correctly identify a fun/arity capture, the zero-arg call + # should be the first argument to a `/` binary op, and that `/` + # should be the only argument to a `&` unary op. + {_, _, []} = call, + {:/, _, [call, {:__block__, _, [arity]}]} = slash, + {:&, _, [slash]} | _ + ], + _position + ) + when is_call(call) and is_integer(arity) do + arity + end + + # Calls not inside of a pipe: + # MyModule.some_function(1, 2) + # some_function.(1, 2) + defp arity_at_position([{_, _, args} = call | _], _position) when is_call(call) do + length(args) + end + + defp arity_at_position([_non_call | rest], %Position{} = position) do + arity_at_position(rest, position) + end + + defp arity_at_position([], _position), do: 0 + + # Walk up the path to see whether we're in the right-hand argument of + # a `::` type operator, which would make the kind a `:type`, not a call. + # Calls that occur on the right of a `::` type operator have kind `:type` + defp kind_of_call([{:"::", _, [_, right_arg]} | rest], %Position{} = position) do + if Ast.contains_position?(right_arg, position) do + :type + else + kind_of_call(rest, position) + end + end + + defp kind_of_call([_ | rest], %Position{} = position) do + kind_of_call(rest, position) + end + + defp kind_of_call([], _position), do: :call + + # There is a fixed set of situations where an alias is being used as + # a `:struct`, otherwise resolve as a `:module`. + defp kind_of_alias(path) + + # |%Foo{} + defp kind_of_alias([{:%, _, _}]), do: :struct + + # %|Foo{} + # %|Foo.Bar{} + # %__MODULE__.|Foo{} + defp kind_of_alias([{:__aliases__, _, _}, {:%, _, _} | _]), do: :struct + + # %|__MODULE__{} + defp kind_of_alias([{:__MODULE__, _, nil}, {:%, _, _} | _]), do: :struct + + # %Foo|{} + defp kind_of_alias([{:%{}, _, _}, {:%, _, _} | _]), do: :struct + + # %|__MODULE__.Foo{} + defp kind_of_alias([head_of_aliases, {:__aliases__, _, [head_of_aliases | _]}, {:%, _, _} | _]) do + :struct + end + + # Catch-all: + defp kind_of_alias(_), do: :module + + defp fetch_module_for_function(analysis, position, function_name, arity) do + with :error <- fetch_module_for_local_function(analysis, position, function_name, arity) do + fetch_module_for_imported_function(analysis, position, function_name, arity) + end + end + + defp fetch_module_for_imported_function(analysis, position, function_name, arity) do + analysis + |> Forge.Analyzer.imports_at(position) + |> Enum.find_value({:error, :not_found}, fn + {imported_module, ^function_name, ^arity} -> + {:ok, imported_module} + + _ -> + false + end) + end + + defp fetch_module_for_local_function(analysis, position, function_name, arity) do + with {:ok, current_module} <- Forge.Analyzer.current_module(analysis, position), + true <- function_exported?(current_module, function_name, arity) do + {:ok, current_module} + else + _ -> :error + end + end + + defp function_exists?(module, function, arity) do + # Wrap the `function_exported?` from `Kernel` to simplify testing. + function_exported?(module, function, arity) + end + + defp current_module(%Analysis{} = analysis, %Position{} = position) do + case Forge.Analyzer.current_module(analysis, position) do + {:ok, module} -> module + _ -> nil + end + end + + defp maybe_local_capture_func(analysis, position) do + with {:ok, %Zipper{node: {:/, _, [_, {:__block__, _, _}]}} = zipper} <- + Ast.zipper_at(analysis.document, position), + true <- inside_capture?(zipper) do + {:/, _, [{local_func_name, _meta, _}, {:__block__, _, [arity]}]} = zipper.node + function_name_length = local_func_name |> to_string() |> String.length() + range = Ast.Range.fetch!(zipper.node, analysis.document) + range = put_in(range.end.character, range.start.character + function_name_length) + + current_module = current_module(analysis, position) + {:ok, {:call, current_module, local_func_name, arity}, range} + else + _ -> + {:error, :not_found} + end + end + + defp inside_capture?(zipper) do + case Zipper.up(zipper) do + %Zipper{node: {:&, _, _}} -> true + _ -> false + end + end +end diff --git a/forge/lib/forge/code_intelligence/references.ex b/forge/lib/forge/code_intelligence/references.ex new file mode 100644 index 00000000..6c034dfe --- /dev/null +++ b/forge/lib/forge/code_intelligence/references.ex @@ -0,0 +1,100 @@ +defmodule Forge.CodeIntelligence.References do + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Location + alias Forge.Document.Position + alias Forge.Analyzer + alias Forge.CodeIntelligence.Entity + alias Forge.CodeIntelligence.Variable + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store + alias Forge.Search.Subject + + require Logger + + def references(%Analysis{} = analysis, %Position{} = position, include_definitions?) do + with {:ok, resolved, _range} <- Entity.resolve(analysis, position) do + resolved + |> maybe_rewrite_resolution(analysis, position) + |> find_references(analysis, position, include_definitions?) + end + end + + defp find_references({:module, module}, _analysis, _position, include_definitions?) do + subject = Subject.module(module) + subtype = subtype(include_definitions?) + + query(subject, type: :module, subtype: subtype) + end + + defp find_references({:struct, struct_module}, _analysis, _position, include_definitions?) do + subject = Subject.module(struct_module) + subtype = subtype(include_definitions?) + + query(subject, type: :struct, subtype: subtype) + end + + defp find_references( + {:call, module, function_name, _arity}, + _analysis, + _position, + include_definitions? + ) do + subject = Subject.mfa(module, function_name, "") + subtype = subtype(include_definitions?) + + case Store.prefix(subject, type: {:function, :_}, subtype: subtype) do + {:ok, entries} -> Enum.map(entries, &to_location/1) + _ -> [] + end + end + + defp find_references( + {:module_attribute, module, attribute_name}, + _analysis, + _position, + include_definitions? + ) do + subject = Subject.module_attribute(module, attribute_name) + subtype = subtype(include_definitions?) + + query(subject, type: :module_attribute, subtype: subtype) + end + + defp find_references({:variable, var_name}, analysis, position, include_definitions?) do + analysis + |> Variable.references(position, var_name, include_definitions?) + |> Enum.map(&to_location/1) + end + + defp find_references(resolved, _, _, _include_definitions?) do + Logger.info("Not attempting to find references for unhandled type: #{inspect(resolved)}") + :error + end + + def maybe_rewrite_resolution({:call, Kernel, :defstruct, 1}, analysis, position) do + case Analyzer.current_module(analysis, position) do + {:ok, struct_module} -> {:struct, struct_module} + orig -> orig + end + end + + def maybe_rewrite_resolution(resolution, _analysis, _position) do + resolution + end + + defp to_location(%Entry{} = entry) do + uri = Document.Path.ensure_uri(entry.path) + Location.new(entry.range, uri) + end + + defp query(subject, opts) do + case Store.exact(subject, opts) do + {:ok, entries} -> Enum.map(entries, &to_location/1) + _ -> [] + end + end + + defp subtype(true = _include_definitions?), do: :_ + defp subtype(false = _include_definitions?), do: :reference +end diff --git a/forge/lib/forge/code_intelligence/structs.ex b/forge/lib/forge/code_intelligence/structs.ex new file mode 100644 index 00000000..d323e792 --- /dev/null +++ b/forge/lib/forge/code_intelligence/structs.ex @@ -0,0 +1,26 @@ +defmodule Forge.CodeIntelligence.Structs do + alias Forge.Module.Loader + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store + + def for_project do + if Mix.Project.get() do + {:ok, structs_from_index()} + else + Forge.Mix.in_project(fn _ -> structs_from_index() end) + end + end + + defp structs_from_index do + case Store.exact(type: :struct, subtype: :definition) do + {:ok, entries} -> + for %Entry{subject: struct_module} <- entries, + Loader.ensure_loaded?(struct_module) do + struct_module + end + + _ -> + [] + end + end +end diff --git a/forge/lib/forge/code_intelligence/symbols.ex b/forge/lib/forge/code_intelligence/symbols.ex new file mode 100644 index 00000000..db703d7b --- /dev/null +++ b/forge/lib/forge/code_intelligence/symbols.ex @@ -0,0 +1,125 @@ +defmodule Forge.CodeIntelligence.Symbols do + alias Forge.Document + alias Forge.Document.Range + alias Forge.CodeIntelligence.Symbols + alias Forge.Search + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors + + @block_types [ + :ex_unit_describe, + :ex_unit_setup, + :ex_unit_setup_all, + :ex_unit_test, + :module + ] + + @symbol_extractors [ + Extractors.FunctionDefinition, + Extractors.Module, + Extractors.ModuleAttribute, + Extractors.StructDefinition, + Extractors.ExUnit + ] + + def for_document(%Document{} = document) do + {:ok, entries} = Indexer.Source.index_document(document, @symbol_extractors) + + definitions = Enum.filter(entries, &(&1.subtype == :definition)) + to_symbols(document, definitions) + end + + def for_workspace(query) do + case Search.Store.fuzzy(query, []) do + {:ok, entries} -> + Enum.map(entries, &Symbols.Workspace.from_entry/1) + + _ -> + [] + end + end + + defp to_symbols(%Document{} = document, entries) do + entries_by_block_id = Enum.group_by(entries, & &1.block_id) + rebuild_structure(entries_by_block_id, document, :root) + end + + defp rebuild_structure(entries_by_block_id, %Document{} = document, block_id) do + block_entries = Map.get(entries_by_block_id, block_id, []) + + Enum.flat_map(block_entries, fn + %Entry{type: {:protocol, _}} = entry -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{type: {:function, type}} = entry when type in [:public, :private] -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{type: type, subtype: :definition} = entry when type in @block_types -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{} = entry -> + case Symbols.Document.from(document, entry) do + {:ok, symbol} -> [symbol] + _ -> [] + end + end) + end + + defp map_block_type(%Document{} = document, %Entry{} = entry, entries_by_block_id) do + result = + if Map.has_key?(entries_by_block_id, entry.id) do + children = + entries_by_block_id + |> rebuild_structure(document, entry.id) + |> Enum.sort_by(&sort_by_start/1) + |> group_functions() + + Symbols.Document.from(document, entry, children) + else + Symbols.Document.from(document, entry) + end + + case result do + {:ok, symbol} -> [symbol] + _ -> [] + end + end + + defp group_functions(children) do + {functions, other} = Enum.split_with(children, &match?({:function, _}, &1.original_type)) + + grouped_functions = + functions + |> Enum.group_by(fn symbol -> + symbol.subject |> String.split(".") |> List.last() |> String.trim() + end) + |> Enum.map(fn + {_name_and_arity, [definition]} -> + definition + + {name_and_arity, [first | _] = defs} -> + last = List.last(defs) + [type, _] = String.split(first.name, " ", parts: 2) + name = "#{type} #{name_and_arity}" + + children = + Enum.map(defs, fn child -> + [_, rest] = String.split(child.name, " ", parts: 2) + %Symbols.Document{child | name: rest} + end) + + range = Range.new(first.range.start, last.range.end) + %Symbols.Document{first | name: name, range: range, children: children} + end) + + grouped_functions + |> Enum.concat(other) + |> Enum.sort_by(&sort_by_start/1) + end + + defp sort_by_start(%Symbols.Document{} = symbol) do + start = symbol.range.start + {start.line, start.character} + end +end diff --git a/forge/lib/forge/code_intelligence/symbols/document.ex b/forge/lib/forge/code_intelligence/symbols/document.ex new file mode 100644 index 00000000..5bf9b53f --- /dev/null +++ b/forge/lib/forge/code_intelligence/symbols/document.ex @@ -0,0 +1,99 @@ +defmodule Forge.CodeIntelligence.Symbols.Document do + alias Forge.Document + alias Forge.Formats + alias Forge.Search.Indexer.Entry + + defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] + + def from(%Document{} = document, %Entry{} = entry, children \\ []) do + case name_and_type(entry.type, entry, document) do + {name, type} -> + range = entry.block_range || entry.range + + {:ok, + %__MODULE__{ + name: name, + type: type, + range: range, + detail_range: entry.range, + children: children, + original_type: entry.type, + subject: entry.subject + }} + + _ -> + :error + end + end + + @do_regex ~r/\s*do\s*$/ + + defp name_and_type({:function, type}, %Entry{} = entry, %Document{} = document) + when type in [:public, :private, :delegate] do + fragment = + document + |> Document.fragment(entry.range.start, entry.range.end) + |> remove_line_breaks_and_multiple_spaces() + + prefix = + case type do + :public -> "def " + :private -> "defp " + :delegate -> "defdelegate " + end + + {prefix <> fragment, entry.type} + end + + @ignored_attributes ~w[spec doc moduledoc derive impl tag] + @type_name_regex ~r/@type\s+[^\s]+/ + + defp name_and_type(:module_attribute, %Entry{} = entry, document) do + case String.split(entry.subject, "@") do + [_, name] when name in @ignored_attributes -> + nil + + [_, "type"] -> + type_text = Document.fragment(document, entry.range.start, entry.range.end) + + name = + case Regex.scan(@type_name_regex, type_text) do + [[match]] -> match + _ -> "@type ??" + end + + {name, :type} + + [_, name] -> + {"@#{name}", :module_attribute} + end + end + + defp name_and_type(ex_unit, %Entry{} = entry, document) + when ex_unit in [:ex_unit_describe, :ex_unit_setup, :ex_unit_test] do + name = + document + |> Document.fragment(entry.range.start, entry.range.end) + |> String.trim() + |> String.replace(@do_regex, "") + + {name, ex_unit} + end + + defp name_and_type(:struct, %Entry{} = entry, _document) do + module_name = Formats.module(entry.subject) + {"%#{module_name}{}", :struct} + end + + defp name_and_type(type, %Entry{subject: name}, _document) when is_atom(name) do + {Formats.module(name), type} + end + + defp name_and_type(type, %Entry{} = entry, _document) do + {to_string(entry.subject), type} + end + + defp remove_line_breaks_and_multiple_spaces(string) do + string |> String.split(~r/\s/) |> Enum.reject(&match?("", &1)) |> Enum.join(" ") + end +end diff --git a/forge/lib/forge/code_intelligence/symbols/workspace.ex b/forge/lib/forge/code_intelligence/symbols/workspace.ex new file mode 100644 index 00000000..ec86fdf5 --- /dev/null +++ b/forge/lib/forge/code_intelligence/symbols/workspace.ex @@ -0,0 +1,55 @@ +defmodule Forge.CodeIntelligence.Symbols.Workspace do + defmodule Link do + defstruct [:uri, :range, :detail_range] + + @type t :: %__MODULE__{ + uri: Forge.uri(), + range: Forge.Document.Range.t(), + detail_range: Forge.Document.Range.t() + } + + def new(uri, range, detail_range \\ nil) do + %__MODULE__{uri: uri, range: range, detail_range: detail_range} + end + end + + alias Forge.Document + alias Forge.Formats + alias Forge.Search.Indexer.Entry + + defstruct [:name, :type, :link, container_name: nil] + + @type t :: %__MODULE__{ + container_name: String.t() | nil, + link: Link.t(), + name: String.t(), + type: atom() + } + + def from_entry(%Entry{} = entry) do + link = + entry.path + |> Document.Path.to_uri() + |> Link.new(entry.block_range, entry.range) + + name = symbol_name(entry.type, entry) + + %__MODULE__{ + name: name, + type: entry.type, + link: link + } + end + + @module_types [:struct, :module] + defp symbol_name(type, entry) when type in @module_types do + Formats.module(entry.subject) + end + + defp symbol_name({:protocol, _}, entry) do + Formats.module(entry.subject) + end + + defp symbol_name(_, entry), + do: entry.subject +end diff --git a/forge/lib/forge/code_intelligence/variable.ex b/forge/lib/forge/code_intelligence/variable.ex new file mode 100644 index 00000000..4c5ae85b --- /dev/null +++ b/forge/lib/forge/code_intelligence/variable.ex @@ -0,0 +1,249 @@ +defmodule Forge.CodeIntelligence.Variable do + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry + + require Logger + + @extractors [Indexer.Extractors.Variable] + + @spec definition(Analysis.t(), Position.t(), atom()) :: {:ok, Entry.t()} | :error + def definition(%Analysis{} = analysis, %Position{} = position, variable_name) do + with {:ok, block_structure, entries} <- index_variables(analysis), + {:ok, %Entry{} = definition_entry} <- + do_find_definition(variable_name, block_structure, entries, position) do + {:ok, definition_entry} + else + _ -> + :error + end + end + + @spec references(Analysis.t(), Position.t(), charlist(), boolean()) :: [Range.t()] + def references( + %Analysis{} = analysis, + %Position{} = position, + variable_name, + include_definitions? \\ false + ) do + with {:ok, block_structure, entries} <- index_variables(analysis), + {:ok, %Entry{} = definition_entry} <- + do_find_definition(variable_name, block_structure, entries, position) do + references = search_for_references(entries, definition_entry, block_structure) + + entries = + if include_definitions? do + [definition_entry | references] + else + references + end + + Enum.sort_by(entries, fn %Entry{} = entry -> + {entry.range.start.line, entry.range.start.character} + end) + else + _ -> + [] + end + end + + defp index_variables(%Analysis{} = analysis) do + with {:ok, entries} <- Indexer.Quoted.index(analysis, @extractors), + {[block_structure], entries} <- Enum.split_with(entries, &(&1.type == :metadata)) do + {:ok, block_structure.subject, entries} + end + end + + defp do_find_definition(variable_name, block_structure, entries, position) do + with {:ok, entry} <- fetch_entry(entries, variable_name, position) do + search_for_definition(entries, entry, block_structure) + end + end + + defp fetch_entry(entries, variable_name, position) do + entries + |> Enum.find(fn %Entry{} = entry -> + entry.subject == variable_name and entry.type == :variable and + Range.contains?(entry.range, position) + end) + |> case do + %Entry{} = entry -> + {:ok, entry} + + _ -> + :error + end + end + + defp search_for_references(entries, %Entry{} = definition_entry, block_structure) do + block_id_to_children = block_id_to_children(block_structure) + + definition_children = Map.get(block_id_to_children, definition_entry.block_id, []) + + # The algorithm here is to first clean up the entries so they either are definitions or references to a + # variable with the given name. We sort them by their occurrence in the file, working backwards on a line, so + # definitions earlier in the line shadow definitions later in the line. + # Then we start at the definition entry, and then for each entry after that, + # if it's a definition, we mark the state as being shadowed, but reset the state if the block + # id isn't in the children of the current block id. If we're not in a child of the current block + # id, then we're no longer shadowed + # + # Note, this algorithm doesn't work when we have a block definition whose result rebinds a variable. + # For example: + # entries = [4, 5, 6] + # entries = + # if something() do + # [1 | entries] + # else + # entries + # end + # Searching for the references to the initial variable won't find anything inside the block, but + # searching for the rebound variable will. + + {entries, _, _} = + entries + |> Enum.filter(fn %Entry{} = entry -> + after_definition? = Position.compare(entry.range.start, definition_entry.range.end) == :gt + + variable_type? = entry.type == :variable + correct_subject? = entry.subject == definition_entry.subject + child_of_definition_block? = entry.block_id in definition_children + + variable_type? and correct_subject? and child_of_definition_block? and after_definition? + end) + |> Enum.sort_by(fn %Entry{} = entry -> + start = entry.range.start + {start.line, -start.character, entry.block_id} + end) + |> Enum.reduce({[], false, definition_entry.block_id}, fn + %Entry{subtype: :definition} = entry, {entries, _, _} -> + # we have a definition that's shadowing our definition entry + {entries, true, entry.block_id} + + %Entry{subtype: :reference} = entry, {entries, true, current_block_id} -> + shadowed? = entry.block_id in Map.get(block_id_to_children, current_block_id, []) + + entries = + if shadowed? do + entries + else + [entry | entries] + end + + {entries, shadowed?, entry.block_id} + + %Entry{} = entry, {entries, false, _} -> + # we're a reference and we're not being shadowed; collect it and move on. + {[entry | entries], false, entry.block_id} + end) + + entries + end + + defp search_for_definition(entries, %Entry{} = entry, block_structure) do + block_id_to_parents = collect_parents(block_structure) + block_path = Map.get(block_id_to_parents, entry.block_id) + entries_by_block_id = entries_by_block_id(entries) + + Enum.reduce_while([entry.block_id | block_path], :error, fn block_id, _ -> + block_entries = + entries_by_block_id + |> Map.get(block_id, []) + |> then(fn entries -> + # In the current block, reject all entries that come after the entry whose definition + # we're searching for. This prevents us from finding definitions who are shadowing + # our entry. For example, the definition on the left of the equals in: `param = param + 1`. + + if block_id == entry.block_id do + Enum.drop_while(entries, &(&1.id != entry.id)) + else + entries + end + end) + + case Enum.find(block_entries, &definition_of?(entry, &1)) do + %Entry{} = definition -> + {:halt, {:ok, definition}} + + nil -> + {:cont, :error} + end + end) + end + + defp definition_of?(%Entry{} = needle, %Entry{} = compare) do + compare.type == :variable and compare.subtype == :definition and + compare.subject == needle.subject + end + + defp entries_by_block_id(entries) do + entries + |> Enum.reduce(%{}, fn %Entry{} = entry, acc -> + Map.update(acc, entry.block_id, [entry], &[entry | &1]) + end) + |> Map.new(fn {block_id, entries} -> + entries = + Enum.sort_by( + entries, + fn %Entry{} = entry -> + {entry.range.start.line, -entry.range.start.character} + end, + :desc + ) + + {block_id, entries} + end) + end + + def block_id_to_parents(hierarchy) do + hierarchy + |> flatten_hierarchy() + |> Enum.reduce(%{}, fn {parent_id, child_id}, acc -> + old_parents = [parent_id | Map.get(acc, parent_id, [])] + Map.update(acc, child_id, old_parents, &Enum.concat(&1, old_parents)) + end) + |> Map.put(:root, []) + end + + def block_id_to_children(hierarchy) do + # Note: Parent ids are included in their children list in order to simplify + # checks for "is this id in one of its children" + + hierarchy + |> flatten_hierarchy() + |> Enum.reverse() + |> Enum.reduce(%{root: [:root]}, fn {parent_id, child_id}, current_mapping -> + current_children = [child_id | Map.get(current_mapping, child_id, [parent_id])] + + current_mapping + |> Map.put_new(child_id, [child_id]) + |> Map.update(parent_id, current_children, &Enum.concat(&1, current_children)) + end) + end + + def flatten_hierarchy(hierarchy) do + Enum.flat_map(hierarchy, fn + {k, v} when is_map(v) and map_size(v) > 0 -> + v + |> Map.keys() + |> Enum.map(&{k, &1}) + |> Enum.concat(flatten_hierarchy(v)) + + _ -> + [] + end) + end + + defp collect_parents(block_structure) do + do_collect_parents(block_structure, %{}, []) + end + + defp do_collect_parents(hierarchy, parent_map, path) do + Enum.reduce(hierarchy, parent_map, fn {block_id, children}, acc -> + parent_map = Map.put(acc, block_id, path) + do_collect_parents(children, parent_map, [block_id | path]) + end) + end +end diff --git a/forge/lib/forge/code_mod/aliases.ex b/forge/lib/forge/code_mod/aliases.ex new file mode 100644 index 00000000..cd623508 --- /dev/null +++ b/forge/lib/forge/code_mod/aliases.ex @@ -0,0 +1,256 @@ +defmodule Forge.CodeMod.Aliases do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Scope + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + + alias Sourceror.Zipper + + @doc """ + Returns the aliases that are in scope at the given range. + """ + @spec in_scope(Analysis.t(), Range.t()) :: [Alias.t()] + def in_scope(%Analysis{} = analysis, %Range{} = range) do + analysis + |> Analysis.module_scope(range) + |> aliases_in_scope() + end + + @doc """ + Sorts the given aliases according to our rules + """ + @spec sort(Enumerable.t(Alias.t())) :: [Alias.t()] + def sort(aliases) do + Enum.sort_by(aliases, fn %Alias{} = scope_alias -> + Enum.map(scope_alias.module, fn elem -> elem |> to_string() |> String.downcase() end) + end) + end + + @doc """ + Returns the position in the document where aliases should be inserted + Since a document can have multiple module definitions, the cursor position is used to + determine the initial starting point. + + This function also returns a string that should be appended to the end of the + edits that are performed. + """ + @spec insert_position(Analysis.t(), Position.t()) :: {Position.t(), String.t() | nil} + def insert_position(%Analysis{} = analysis, %Position{} = cursor_position) do + range = Range.new(cursor_position, cursor_position) + current_aliases = in_scope(analysis, range) + do_insert_position(analysis, current_aliases, range) + end + + @doc """ + Turns a list of aliases into aliases into edits + """ + @spec to_edits([Alias.t()], Position.t(), trailer :: String.t() | nil) :: [Edit.t()] + + def to_edits(aliases, position, trailer \\ nil) + def to_edits([], _, _), do: [] + + def to_edits(aliases, %Position{} = insert_position, trailer) do + aliases = sort(aliases) + initial_spaces = insert_position.character - 1 + + alias_text = + aliases + # get rid of duplicate aliases + |> Enum.uniq_by(& &1.module) + |> Enum.map_join("\n", fn %Alias{} = a -> + text = + if List.last(a.module) == a.as do + "alias #{join(a.module)}" + else + "alias #{join(a.module)}, as: #{join(List.wrap(a.as))}" + end + + indent(text, initial_spaces) + end) + |> String.trim_trailing() + + zeroed = put_in(insert_position.character, 1) + new_alias_range = Range.new(zeroed, zeroed) + + alias_text = + if is_binary(trailer) do + alias_text <> trailer + else + alias_text + end + + edits = remove_old_aliases(aliases) + + edits ++ + [Edit.new(alias_text, new_alias_range)] + end + + defp aliases_in_scope(%Scope{} = scope) do + scope.aliases + |> Enum.filter(fn %Alias{} = scope_alias -> + scope_alias.explicit? and Range.contains?(scope.range, scope_alias.range.start) + end) + |> sort() + end + + defp join(module) do + Enum.join(module, ".") + end + + defp indent(text, spaces) do + String.duplicate(" ", spaces) <> text + end + + defp remove_old_aliases(aliases) do + ranges = + aliases + # Reject new aliases that don't have a range + |> Enum.reject(&is_nil(&1.range)) + # iterating back to start means we won't have prior edits + # clobber subsequent edits + |> Enum.sort_by(& &1.range.start.line, :desc) + |> Enum.uniq_by(& &1.range) + |> Enum.map(fn %Alias{} = alias -> + orig_range = alias.range + + orig_range + |> put_in([:start, :character], 1) + |> update_in([:end], fn %Position{} = pos -> + %Position{pos | character: 1, line: pos.line + 1} + end) + end) + + first_alias_index = length(ranges) - 1 + + ranges + |> Enum.with_index() + |> Enum.map(fn + {range, ^first_alias_index} -> + # add a new line where the first alias was to make space + # for the rewritten aliases + Edit.new("\n", range) + + {range, _} -> + Edit.new("", range) + end) + |> merge_adjacent_edits() + end + + defp merge_adjacent_edits([]), do: [] + defp merge_adjacent_edits([_] = edit), do: edit + + defp merge_adjacent_edits([edit | rest]) do + rest + |> Enum.reduce([edit], fn %Edit{} = current, [%Edit{} = last | rest] = edits -> + with {same_text, same_text} <- {last.text, current.text}, + {same, same} <- {to_tuple(current.range.end), to_tuple(last.range.start)} do + collapsed = put_in(current.range.end, last.range.end) + + [collapsed | rest] + else + _ -> + [current | edits] + end + end) + |> Enum.reverse() + end + + defp to_tuple(%Position{} = position) do + {position.line, position.character} + end + + defp do_insert_position(%Analysis{}, [%Alias{} | _] = aliases, _) do + first = Enum.min_by(aliases, &{&1.range.start.line, &1.range.start.character}) + {first.range.start, nil} + end + + defp do_insert_position(%Analysis{} = analysis, _, range) do + case Analysis.module_scope(analysis, range) do + %Scope{id: :global} = scope -> + {scope.range.start, "\n"} + + %Scope{} = scope -> + scope_start = scope.range.start + # we use the end position here because the start position is right after + # the do for modules, which puts it well into the line. The end position + # is before the end, which is equal to the indent of the scope. + + initial_position = + scope_start + |> put_in([:line], scope_start.line + 1) + |> put_in([:character], scope.range.end.character) + |> constrain_to_range(scope.range) + + position = + case Ast.zipper_at(analysis.document, scope_start) do + {:ok, zipper} -> + {_, position} = + Zipper.traverse(zipper, initial_position, fn + %Zipper{node: {:@, _, [{:moduledoc, _, _}]}} = zipper, _acc -> + # If we detect a moduledoc node, place the alias after it + range = Sourceror.get_range(zipper.node) + + {zipper, after_node(analysis.document, scope.range, range)} + + zipper, acc -> + {zipper, acc} + end) + + position + + _ -> + initial_position + end + + maybe_move_cursor_to_token_start(position, analysis) + end + end + + defp after_node(%Document{} = document, %Range{} = scope_range, %{ + start: start_pos, + end: end_pos + }) do + document + |> Position.new(end_pos[:line] + 1, start_pos[:column]) + |> constrain_to_range(scope_range) + end + + defp constrain_to_range(%Position{} = position, %Range{} = scope_range) do + cond do + position.line == scope_range.end.line -> + character = min(scope_range.end.character, position.character) + %Position{position | character: character} + + position.line > scope_range.end.line -> + %Position{scope_range.end | character: 1} + + true -> + position + end + end + + defp maybe_move_cursor_to_token_start(%Position{} = position, %Analysis{} = analysis) do + project = Forge.get_project() + + with {:ok, env} <- Ast.Env.new(project, analysis, position), + false <- String.last(env.prefix) in [" ", ""] do + # ` en|d` -> `2` + # `en|d` -> `2` + non_empty_characters_count = env.prefix |> String.trim_leading() |> String.length() + + new_position = %Position{ + position + | character: position.character - non_empty_characters_count + } + + {new_position, "\n"} + else + _ -> + {position, "\n"} + end + end +end diff --git a/forge/lib/forge/code_mod/diff.ex b/forge/lib/forge/code_mod/diff.ex new file mode 100644 index 00000000..7e63e4a0 --- /dev/null +++ b/forge/lib/forge/code_mod/diff.ex @@ -0,0 +1,121 @@ +defmodule Forge.CodeMod.Diff do + alias Forge.CodeUnit + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + + @spec diff(Document.t(), String.t()) :: [Edit.t()] + def diff(%Document{} = document, dest) when is_binary(dest) do + document + |> Document.to_string() + |> String.myers_difference(dest) + |> to_edits(document) + end + + defp to_edits(difference, %Document{} = document) do + {_, {current_line, prev_lines}} = + Enum.reduce(difference, {{starting_line(), starting_character()}, {[], []}}, fn + {diff_type, diff_string}, {position, edits} -> + apply_diff(diff_type, position, diff_string, edits, document) + end) + + [current_line | prev_lines] + |> Enum.flat_map(fn line_edits -> + line_edits + |> Enum.reduce([], &collapse/2) + |> Enum.reverse() + end) + end + + # This collapses a delete and an an insert that are adjacent to one another + # into a single insert, changing the delete to insert the text from the + # insert rather than "" + # It's a small optimization, but it was in the original + defp collapse( + %Edit{ + text: "", + range: %Range{ + end: %Position{character: same_character, line: same_line} + } + } = delete_edit, + [ + %Edit{ + text: insert_text, + range: + %Range{ + start: %Position{character: same_character, line: same_line} + } = _insert_edit + } + | rest + ] + ) + when byte_size(insert_text) > 0 do + collapsed_edit = %Edit{delete_edit | text: insert_text} + [collapsed_edit | rest] + end + + defp collapse(%Edit{} = edit, edits) do + [edit | edits] + end + + defp apply_diff(:eq, position, doc_string, edits, _document) do + advance(doc_string, position, edits) + end + + defp apply_diff(:del, {line, code_unit} = position, change, edits, document) do + {after_pos, {current_line, prev_lines}} = advance(change, position, edits) + {edit_end_line, edit_end_unit} = after_pos + + current_line = [ + edit(document, "", line, code_unit, edit_end_line, edit_end_unit) | current_line + ] + + {after_pos, {current_line, prev_lines}} + end + + defp apply_diff( + :ins, + {line, code_unit} = position, + change, + {current_line, prev_lines}, + document + ) do + current_line = [edit(document, change, line, code_unit, line, code_unit) | current_line] + {position, {current_line, prev_lines}} + end + + defp advance(<<>>, position, edits) do + {position, edits} + end + + for ending <- ["\r\n", "\r", "\n"] do + defp advance(<>, {line, _unit}, {current_line, prev_lines}) do + edits = {[], [current_line | prev_lines]} + advance(rest, {line + 1, starting_character()}, edits) + end + end + + defp advance(<>, {line, unit}, edits) when c < 128 do + advance(rest, {line, unit + 1}, edits) + end + + defp advance(<>, {line, unit}, edits) do + increment = CodeUnit.count(:utf8, <>) + advance(rest, {line, unit + increment}, edits) + end + + defp edit(document, text, start_line, start_unit, end_line, end_unit) + when is_binary(text) do + Edit.new( + text, + Range.new( + Position.new(document, start_line, start_unit), + Position.new(document, end_line, end_unit) + ) + ) + end + + defp starting_line, do: 1 + defp starting_character, do: 1 +end diff --git a/forge/lib/forge/code_mod/format.ex b/forge/lib/forge/code_mod/format.ex new file mode 100644 index 00000000..09a65e87 --- /dev/null +++ b/forge/lib/forge/code_mod/format.ex @@ -0,0 +1,238 @@ +defmodule Forge.CodeMod.Format do + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Project + + alias Engine.Build + alias Forge.CodeMod.Diff + + require Logger + + @built_in_locals_without_parens [ + # Special forms + alias: 1, + alias: 2, + case: 2, + cond: 1, + for: :*, + import: 1, + import: 2, + quote: 1, + quote: 2, + receive: 1, + require: 1, + require: 2, + try: 1, + with: :*, + + # Kernel + def: 1, + def: 2, + defp: 1, + defp: 2, + defguard: 1, + defguardp: 1, + defmacro: 1, + defmacro: 2, + defmacrop: 1, + defmacrop: 2, + defmodule: 2, + defdelegate: 2, + defexception: 1, + defoverridable: 1, + defstruct: 1, + destructure: 2, + raise: 1, + raise: 2, + reraise: 2, + reraise: 3, + if: 2, + unless: 2, + use: 1, + use: 2, + + # Stdlib, + defrecord: 2, + defrecord: 3, + defrecordp: 2, + defrecordp: 3, + + # Testing + assert: 1, + assert: 2, + assert_in_delta: 3, + assert_in_delta: 4, + assert_raise: 2, + assert_raise: 3, + assert_receive: 1, + assert_receive: 2, + assert_receive: 3, + assert_received: 1, + assert_received: 2, + doctest: 1, + doctest: 2, + refute: 1, + refute: 2, + refute_in_delta: 3, + refute_in_delta: 4, + refute_receive: 1, + refute_receive: 2, + refute_receive: 3, + refute_received: 1, + refute_received: 2, + setup: 1, + setup: 2, + setup_all: 1, + setup_all: 2, + test: 1, + test: 2, + + # Mix config + config: 2, + config: 3, + import_config: 1 + ] + + @type formatter_function :: (String.t() -> any) | nil + + @spec edits(Document.t()) :: {:ok, Changes.t()} | {:error, any} + def edits(%Document{} = document) do + project = Forge.get_project() + + with :ok <- Build.compile_document(project, document), + {:ok, formatted} <- do_format(project, document) do + edits = Diff.diff(document, formatted) + {:ok, Changes.new(document, edits)} + end + end + + defp do_format(%Project{} = project, %Document{} = document) do + project_path = Project.project_path(project) + + with :ok <- check_current_directory(document, project_path), + {:ok, formatter} <- formatter_for(project, document.path) do + document + |> Document.to_string() + |> formatter.() + end + end + + @spec formatter_for(Project.t(), String.t()) :: {:ok, formatter_function} + defp formatter_for(%Project{} = project, uri_or_path) do + path = Document.Path.ensure_path(uri_or_path) + {formatter_function, _opts} = formatter_for_file(project, path) + wrapped_formatter_function = wrap_with_try_catch(formatter_function) + {:ok, wrapped_formatter_function} + end + + defp wrap_with_try_catch(formatter_fn) do + fn code -> + try do + {:ok, formatter_fn.(code)} + rescue + e -> + {:error, e} + end + end + end + + defp check_current_directory(%Document{} = document, project_path) do + if subdirectory?(document.path, parent: project_path) do + :ok + else + message = + """ + Cannot format file #{document.path}. + It is not in the project at #{project_path} + """ + |> String.trim() + + {:error, message} + end + end + + defp subdirectory?(child, parent: parent) do + normalized_parent = Path.absname(parent) + String.starts_with?(child, normalized_parent) + end + + @doc """ + Returns `{formatter_function, opts}` for the given file. + """ + def formatter_for_file(%Project{} = project, file_path) do + fetch_formatter = fn _ -> Mix.Tasks.Format.formatter_for_file(file_path) end + + {formatter_function, opts} = + if Forge.project_node?() do + case Forge.Mix.in_project(project, fetch_formatter) do + {:ok, result} -> + result + + _error -> + formatter_opts = + case find_formatter_exs(project, file_path) do + {:ok, opts} -> + opts + + :error -> + Logger.warning("Could not find formatter options for file #{file_path}") + [] + end + + formatter = fn source -> + formatted_source = Code.format_string!(source, formatter_opts) + IO.iodata_to_binary([formatted_source, ?\n]) + end + + {formatter, formatter_opts} + end + else + fetch_formatter.(nil) + end + + opts = + Keyword.update( + opts, + :locals_without_parens, + @built_in_locals_without_parens, + &(@built_in_locals_without_parens ++ &1) + ) + + {formatter_function, opts} + end + + defp find_formatter_exs(%Project{} = project, file_path) do + root_dir = Project.root_path(project) + do_find_formatter_exs(root_dir, file_path) + end + + defp do_find_formatter_exs(root_path, root_path) do + formatter_exs_contents(root_path) + end + + defp do_find_formatter_exs(root_path, current_path) do + with :error <- formatter_exs_contents(current_path) do + parent = + current_path + |> Path.join("..") + |> Path.expand() + + do_find_formatter_exs(root_path, parent) + end + end + + defp formatter_exs_contents(current_path) do + formatter_exs = Path.join(current_path, ".formatter.exs") + + with true <- File.exists?(formatter_exs), + {formatter_terms, _binding} <- Code.eval_file(formatter_exs) do + Logger.info("found formatter in #{current_path}") + {:ok, formatter_terms} + else + err -> + Logger.info("No formatter found in #{current_path} error was #{inspect(err)}") + + :error + end + end +end diff --git a/forge/lib/forge/code_unit.ex b/forge/lib/forge/code_unit.ex new file mode 100644 index 00000000..ce2d67dc --- /dev/null +++ b/forge/lib/forge/code_unit.ex @@ -0,0 +1,125 @@ +defmodule Forge.CodeUnit do + @moduledoc """ + Code unit and offset conversions. + + LSP positions are encoded as UTF-16 code unit offsets from the beginning of a line, + while positions in Elixir are UTF-8 character positions (graphemes). This module + deals with converting between the two. + """ + + @type utf8_character_position :: non_neg_integer() + @type utf8_code_unit_offset :: non_neg_integer() + @type utf16_code_unit_offset :: non_neg_integer() + + @type error :: {:error, :misaligned} | {:error, :out_of_bounds} + + @doc """ + Converts a 0-based UTF-8 character position to a UTF-16 code unit offset. + """ + @spec utf8_position_to_utf16_offset(String.t(), utf8_character_position()) :: + utf16_code_unit_offset() + def utf8_position_to_utf16_offset(binary, character_position) do + binary + |> String.slice(0, character_position) + |> :unicode.characters_to_binary(:utf8, :utf16) + |> byte_size() + |> div(2) + end + + @doc """ + Converts a 0-based UTF-16 code unit offset to a UTF-8 code unit offset. + """ + @spec utf16_offset_to_utf8_offset(String.t(), utf16_code_unit_offset()) :: + {:ok, utf8_code_unit_offset()} | error + def utf16_offset_to_utf8_offset(binary, utf16_unit) do + do_to_utf8(binary, utf16_unit, 1) + end + + @doc """ + Counts the number of utf16 code units in the binary + """ + @spec count(:utf16 | :utf8, binary()) :: non_neg_integer + def count(:utf16, binary) do + do_count_utf16(binary, 0) + end + + def count(:utf8, binary) do + do_count_utf8(binary, 0) + end + + # Private + + # UTF-16 + + defp do_count_utf16(<<>>, count) do + count + end + + defp do_count_utf16(<>, count) when c < 128 do + do_count_utf16(rest, count + 1) + end + + defp do_count_utf16(<>, count) do + do_count_utf16(rest, count + code_unit_size(c, :utf16)) + end + + defp do_count_utf8(<<>>, count) do + count + end + + defp do_count_utf8(<>, count) when c < 128 do + do_count_utf8(rest, count + 1) + end + + defp do_count_utf8(<>, count) do + increment = code_unit_size(c, :utf8) + do_count_utf8(rest, count + increment) + end + + # UTF-8 + + defp do_to_utf8(_, 0, utf8_unit) do + {:ok, utf8_unit} + end + + defp do_to_utf8(_, utf_16_units, _) when utf_16_units < 0 do + {:error, :misaligned} + end + + defp do_to_utf8(<<>>, _remaining, _utf8_unit) do + {:error, :out_of_bounds} + end + + defp do_to_utf8(<>, utf16_unit, utf8_unit) when c < 128 do + do_to_utf8(rest, utf16_unit - 1, utf8_unit + 1) + end + + defp do_to_utf8(<>, utf16_unit, utf8_unit) do + utf8_code_units = code_unit_size(c, :utf8) + utf16_code_units = code_unit_size(c, :utf16) + + do_to_utf8(rest, utf16_unit - utf16_code_units, utf8_unit + utf8_code_units) + end + + @unicode_range 0..0x10_FFFF + + defp code_unit_size(c, :utf16) when c in @unicode_range do + case c do + c when c in 0x0000..0xFFFF -> + 1 + + _ -> + 2 + end + end + + defp code_unit_size(c, :utf8) when c in @unicode_range do + # See table at https://en.wikipedia.org/wiki/UTF-8#Encoding + cond do + c in 0x00..0x7F -> 1 + c in 0x80..0x7FF -> 2 + c in 0x800..0xFFFF -> 3 + c in 0x1_0000..0x10_FFFF -> 4 + end + end +end diff --git a/forge/lib/forge/completion/candidate.ex b/forge/lib/forge/completion/candidate.ex new file mode 100644 index 00000000..d7cabc8b --- /dev/null +++ b/forge/lib/forge/completion/candidate.ex @@ -0,0 +1,302 @@ +defmodule Forge.Completion.Candidate do + alias Forge.Completion.Candidate.ArgumentNames + require Logger + + defmodule Function do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :name, + :origin, + :type, + :visibility, + :spec, + :summary, + :metadata, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Callback do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :metadata, + :name, + :origin, + :spec, + :summary, + :type, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Macro do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :name, + :origin, + :type, + :visibility, + :spec, + :metadata, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Typespec do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :doc, + :metadata, + :type, + :name, + :origin, + :signature, + :spec, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Module do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Exception do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Behaviour do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Protocol do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Struct do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule StructField do + @moduledoc false + defstruct [:call?, :name, :origin, :type_spec] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + + def new(name, origin) do + %__MODULE__{name: name, origin: origin, call?: false} + end + end + + defmodule MapField do + @moduledoc false + defstruct [:call?, :name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule ModuleAttribute do + @moduledoc false + defstruct [:name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Variable do + @moduledoc false + defstruct [:name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Snippet do + @moduledoc false + defstruct [:detail, :documentation, :filter_text, :kind, :label, :priority, :snippet] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule MixTask do + defstruct [:full_name, :metadata, :name, :subtype, :summary, :type] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule BitstringOption do + defstruct [:name, :type] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + def from_elixir_sense(%{type: :module, subtype: nil} = elixir_sense_map) do + Module.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :alias} = elixir_sense_map) do + Module.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :behaviour} = elixir_sense_map) do + Behaviour.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :exception} = elixir_sense_map) do + Exception.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :struct} = elixir_sense_map) do + Struct.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :protocol} = elixir_sense_map) do + Protocol.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :task} = elixir_sense_map) do + MixTask.new(elixir_sense_map) + end + + # elixir_sense suggests test cases as functions, which need to be filtered. + def from_elixir_sense(%{type: :function, name: "test " <> _} = _elixir_sense_map) do + nil + end + + def from_elixir_sense(%{type: :function} = elixir_sense_map) do + Function.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :macro} = elixir_sense_map) do + Macro.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :type_spec} = elixir_sense_map) do + Typespec.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :bitstring_option} = elixir_sense_map) do + BitstringOption.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :attribute} = elixir_sense_map) do + ModuleAttribute.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :generic, kind: :snippet} = elixir_sense_map) do + Snippet.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :variable} = elixir_sense_map) do + Variable.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :field, subtype: :struct_field} = elixir_sense_map) do + StructField.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :field, subtype: :map_key} = elixir_sense_map) do + MapField.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :callback} = elixir_sense_map) do + Callback.new(elixir_sense_map) + end + + def from_elixir_sense(elixir_sense_map) do + Logger.warning("Unhandled completion suggestion: #{inspect(elixir_sense_map)}") + nil + end +end diff --git a/forge/lib/forge/completion/candidate/argument_names.ex b/forge/lib/forge/completion/candidate/argument_names.ex new file mode 100644 index 00000000..1fccfed5 --- /dev/null +++ b/forge/lib/forge/completion/candidate/argument_names.ex @@ -0,0 +1,120 @@ +defmodule Forge.Completion.Candidate.ArgumentNames do + @moduledoc """ + Elixir sense, for whatever reason returns all the argument names when asked to do a completion on a function. + This means that the arity of the function might differ from the argument names returned. Furthermore, the + argument names have the defaults in them for some reason, which is completely unhelpful for completions. + + The functions below match the arity of the argument names to the given arity, and strip out the defaults, + rendering the results useful for completion. + """ + + alias Future.Code, as: Code + + @type argument_names :: [String.t()] + @default_specifier ~S(\\) + + @spec from_elixir_sense_map(map()) :: :error | argument_names() + def from_elixir_sense_map(%{args_list: argument_names, arity: arity}) do + from_elixir_sense(argument_names, arity) + end + + def from_elixir_sense_map(%{}) do + :error + end + + @spec from_elixir_sense([String.t()], non_neg_integer) :: :error | argument_names() + def from_elixir_sense(argument_names, arity) when is_list(argument_names) do + {names, required_count} = preprocess(argument_names) + + cond do + length(argument_names) < arity -> + :error + + arity < required_count -> + :error + + true -> + generate_argument_list(names, required_count, arity) + end + end + + defp generate_argument_list(names, required_count, arity) do + optional_count = arity - required_count + + {arg_list, _} = + Enum.reduce(names, {[], optional_count}, fn + {:required, arg_name}, {arg_list, optional_count} -> + {[arg_name | arg_list], optional_count} + + {:optional, _}, {_arg_list, 0} = acc -> + acc + + {:optional, arg_name}, {arg_list, optional_count} -> + {[arg_name | arg_list], optional_count - 1} + end) + + Enum.reverse(arg_list) + end + + defp split_on_default(argument) do + argument + |> String.split(@default_specifier) + |> Enum.map(&String.trim/1) + end + + @spec preprocess(argument_names()) :: {[String.t()], non_neg_integer()} + defp preprocess(argument_names) do + {names, required_count} = + argument_names + |> Enum.with_index(1) + |> Enum.reduce({[], 0}, fn {argument, index}, {names, required_count} -> + {name, increment} = + case split_on_default(argument) do + [argument_name] -> + {{:required, extract_name(argument_name, index)}, 1} + + [argument_name, _default] -> + {{:optional, extract_name(argument_name, index)}, 0} + end + + {[name | names], required_count + increment} + end) + + {Enum.reverse(names), required_count} + end + + defp extract_name(argument, index) do + case Code.Fragment.cursor_context(argument) do + {:unquoted_atom, atom} -> + ":#{atom}" + + {:local_or_var, name} -> + List.to_string(name) + + :none -> + argument + |> String.split("=") + |> find_local_in_pattern_match(index) + + _ -> + argument + end + end + + defp find_local_in_pattern_match([], index) do + "arg_#{index}" + end + + defp find_local_in_pattern_match([first | rest], index) do + case Code.Fragment.cursor_context(first) do + {:local_or_var, name} -> + List.to_string(name) + + {:local_call, name} -> + List.to_string(name) + + _ -> + find_local_in_pattern_match(rest, index) + end + end +end diff --git a/forge/lib/forge/convertible.ex b/forge/lib/forge/convertible.ex new file mode 100644 index 00000000..c49ee8d9 --- /dev/null +++ b/forge/lib/forge/convertible.ex @@ -0,0 +1,215 @@ +defmodule Forge.Convertible.Helpers do + @moduledoc false + + alias Forge.Document + + def apply(%{} = map, func) do + result = + Enum.reduce_while(map, [], fn {key, value}, acc -> + case func.(value) do + {:ok, native} -> + {:cont, [{key, native} | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + {:ok, Map.new(l)} + + other -> + other + end + end + + def apply(enumerable, func) do + result = + Enum.reduce_while(enumerable, [], fn elem, acc -> + case func.(elem) do + {:ok, native} -> + {:cont, [native | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + {:ok, Enum.reverse(l)} + + error -> + error + end + end + + def apply(%{} = map, func, context_document) do + Enum.reduce_while(map, [], fn {key, value}, acc -> + context_document = Document.Container.context_document(value, context_document) + + case func.(value, context_document) do + {:ok, native} -> + {:cont, [{key, native} | acc]} + + error -> + {:halt, error} + end + end) + end + + def apply(enumerable, func, context_document) do + result = + Enum.reduce_while(enumerable, [], fn elem, acc -> + context_document = Document.Container.context_document(elem, context_document) + + case func.(elem, context_document) do + {:ok, native} -> + {:cont, [native | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + Enum.reverse(l) + + error -> + error + end + end +end + +defprotocol Forge.Convertible do + @moduledoc """ + A protocol that details conversions to and from Language Server idioms + + The [Language Server specification](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/) + defines a couple of data structures that differ wildly from similar data structures and concepts in Elixir. Among these are + positions and ranges. Elixir's parser thinks in terms of UTF-8 graphemes and uses one-based line and column numbers, while the + language server speaks in UTF-16 code unit offsets and uses zero-based line and character (a misnomer, in reality this is a + UTF-16 code unit) offsets. If not handled centrally, this leads to a profusion of conversion code throughout the language + server codebase. + + That's where this protocol comes in. Using this protocol allows us to define native `Forge.Document.Position` and + `Forge.Document.Range` structs and have them automatically convert into their Language Server counterparts, centralizing + the conversion logic in a single pace. + + Note: You do not need to do conversions manually, If you define a new type, it is sufficient to implement this + protocol for your new type + """ + alias Forge.Document + + @fallback_to_any true + + @typedoc "Any type that can be converted using this protocol" + @type t :: term() + + @typedoc "A native term that contains ranges, positions or both" + @type native :: term() + + @typedoc "A Language server term" + @type lsp :: term() + + @typedoc "The result of converting a lsp term into a native term" + @type native_response :: {:ok, native()} | {:error, term} + + @typedoc "The result of converting a native term into a lsp term" + @type lsp_response :: {:ok, lsp()} | {:error, term} + + @doc """ + Converts the structure to a native implementation + """ + @spec to_native(t, Document.Container.maybe_context_document()) :: native_response() + def to_native(t, context_document) + + @doc """ + Converts the native representation to a LSP compatible struct + """ + @spec to_lsp(t) :: lsp_response() + def to_lsp(t) +end + +defimpl Forge.Convertible, for: List do + alias Forge.Convertible + alias Forge.Convertible.Helpers + + def to_native(l, context_document) do + case Helpers.apply(l, &Convertible.to_native/2, context_document) do + l when is_list(l) -> + {:ok, l} + + error -> + error + end + end + + def to_lsp(l) do + Helpers.apply(l, &Convertible.to_lsp/1) + end +end + +defimpl Forge.Convertible, for: Map do + alias Forge.Convertible + alias Forge.Convertible.Helpers + + def to_native(map, context_document) do + case Helpers.apply(map, &Convertible.to_native/2, context_document) do + l when is_list(l) -> {:ok, Map.new(l)} + error -> error + end + end + + def to_lsp(map) do + Helpers.apply(map, &Convertible.to_lsp/1) + end +end + +defimpl Forge.Convertible, for: Any do + alias Forge.Convertible + alias Forge.Document + alias Forge.Convertible.Helpers + + def to_native(%_struct_module{} = struct, context_document) do + context_document = Document.Container.context_document(struct, context_document) + + result = + struct + |> Map.from_struct() + |> Helpers.apply(&Convertible.to_native/2, context_document) + + case result do + l when is_list(l) -> + {:ok, Map.merge(struct, Map.new(l))} + + error -> + error + end + end + + def to_native(any, _context_document) do + {:ok, any} + end + + def to_lsp(%_struct_module{} = struct) do + result = + struct + |> Map.from_struct() + |> Helpers.apply(&Convertible.to_lsp/1) + + case result do + {:ok, map} -> + {:ok, Map.merge(struct, map)} + + error -> + error + end + end + + def to_lsp(any) do + {:ok, any} + end +end diff --git a/forge/lib/forge/dispatch.ex b/forge/lib/forge/dispatch.ex new file mode 100644 index 00000000..c4a61e36 --- /dev/null +++ b/forge/lib/forge/dispatch.ex @@ -0,0 +1,84 @@ +defmodule Forge.Dispatch do + @moduledoc """ + A global event dispatcher for lexical. + + Dispatch allows two recipients of its messages, processes and modules. A process must register + itself via a call to `register_listener`, while a process must implement the + `Forge.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. + """ + + alias Forge.Dispatch.Handlers + alias Forge.Dispatch.PubSub + import Forge.Api.Messages + + @handlers [PubSub, Handlers.Indexing] + + # public API + + @doc """ + Registers a process that will receive messages sent directly to its pid. + """ + + def register_listener(listener_pid, message_types) when is_list(message_types) do + :gen_event.call(__MODULE__, PubSub, PubSub.register_message(listener_pid, message_types)) + end + + def register_listener(listener_pid, event_or_all) do + register_listener(listener_pid, List.wrap(event_or_all)) + end + + def add_handler(handler_module, init_args \\ []) do + :gen_event.add_handler(__MODULE__, handler_module, init_args) + end + + def registered?(pid) when is_pid(pid) do + :gen_event.call(__MODULE__, PubSub, PubSub.registered_message(pid)) + end + + def registered?(name) when is_atom(name) do + name in :gen_event.which_handlers(__MODULE__) + end + + def broadcast(message) do + :gen_event.notify(__MODULE__, message) + end + + # GenServer callbacks + + def start_link(opts) do + case :gen_event.start_link(name()) do + {:ok, pid} = success -> + Enum.each(@handlers, &:gen_event.add_handler(pid, &1, [])) + + if opts[:progress] do + register_progress_listener() + end + + success + + error -> + error + end + end + + def child_spec(opts) do + %{ + id: {__MODULE__, :dispatch}, + start: {__MODULE__, :start_link, [opts]} + } + end + + defp name do + {:local, __MODULE__} + end + + defp register_progress_listener do + register_listener(progress_pid(), [project_progress(), percent_progress()]) + end + + defp progress_pid do + project = Forge.get_project() + manager_node_name = Engine.manager_node_name(project) + :rpc.call(manager_node_name, Engine.Server.Project.Progress, :whereis, [project]) + end +end diff --git a/forge/lib/forge/dispatch/handler.ex b/forge/lib/forge/dispatch/handler.ex new file mode 100644 index 00000000..1447003d --- /dev/null +++ b/forge/lib/forge/dispatch/handler.ex @@ -0,0 +1,105 @@ +defmodule Forge.Dispatch.Handler do + @moduledoc """ + Defines a handler that selectively receives events emitted from a remote control node. + + ## Usage + + Define a handler, specifying the events to be handled and implementing `on_event/2`: + + defmodule MyHandler do + alias Forge.Api.Messages + alias Forge.Dispatch.Handler + + import Messages + + use Handler, [project_compiled()] + + def on_event(project_compiled(), state) do + ...do something with the message + {:ok, state} + end + end + + Register the handler with dispatch: + + # The second argument here will be passed to the `init/1` callback + Forge.Dispatch.add_handler(MyHandler, init_arg) + + """ + @type event :: tuple() + @type handler_state :: term() + + @callback on_event(event(), handler_state) :: {:ok, handler_state} | {:error, any()} + @callback init(term()) :: {:ok, handler_state()} + @optional_callbacks init: 1 + + defmacro __using__(event_types) do + event_types = List.wrap(event_types) + + handler_bodies = + if Enum.member?(event_types, :all) do + [all_handler()] + else + handler_bodies(event_types) + end + + quote do + @behaviour unquote(__MODULE__) + + def init(arg) do + {:ok, arg} + end + + def on(event, state) do + {:ok, event, state} + end + + def handle_call(_, state) do + {:ok, state} + end + + def handle_info(_, state) do + {:ok, state} + end + + unquote_splicing(handler_bodies) + + # handlers only respond to on or info, not calls. + defoverridable init: 1, handle_info: 2, on: 2 + end + end + + def handler_bodies(event_types) do + results = + Enum.map(event_types, fn {event_name, _, _} -> + event_handler(event_name) + end) + + results ++ [ignore_handler()] + end + + defp event_handler(event_name) do + quote do + def handle_event(event, state) + when is_tuple(event) and elem(event, 0) == unquote(event_name) do + on_event(event, state) + end + end + end + + defp all_handler do + quote do + def handle_event(event, state) do + on_event(event, state) + end + end + end + + defp ignore_handler do + quote do + def handle_event(event, state) do + {:ok, state} + end + end + end +end diff --git a/forge/lib/forge/dispatch/handlers/indexing.ex b/forge/lib/forge/dispatch/handlers/indexing.ex new file mode 100644 index 00000000..adf5e016 --- /dev/null +++ b/forge/lib/forge/dispatch/handlers/indexing.ex @@ -0,0 +1,36 @@ +defmodule Forge.Dispatch.Handlers.Indexing do + alias Forge.Document + alias Forge.Api.Messages + alias Engine.Commands + alias Forge.Dispatch + alias Forge.Search + + require Logger + import Messages + + use Dispatch.Handler, [file_compile_requested(), filesystem_event()] + + def on_event(file_compile_requested(uri: uri), state) do + reindex(uri) + {:ok, state} + end + + def on_event(filesystem_event(uri: uri, event_type: :deleted), state) do + delete_path(uri) + {:ok, state} + end + + def on_event(filesystem_event(), state) do + {:ok, state} + end + + defp reindex(uri) do + Commands.Reindex.uri(uri) + end + + def delete_path(uri) do + uri + |> Document.Path.ensure_path() + |> Search.Store.clear() + end +end diff --git a/forge/lib/forge/dispatch/pub_sub.ex b/forge/lib/forge/dispatch/pub_sub.ex new file mode 100644 index 00000000..747bcf28 --- /dev/null +++ b/forge/lib/forge/dispatch/pub_sub.ex @@ -0,0 +1,120 @@ +defmodule Forge.Dispatch.PubSub do + @moduledoc """ + A pubsub event handler for a gen_event controller. + """ + defmodule State do + alias Forge.Project + + defstruct [:registrations] + + def new do + %__MODULE__{registrations: %{}} + end + + def add(%__MODULE__{} = state, message_type, pid) do + registrations = + Map.update(state.registrations, message_type, [pid], fn registrations -> + [pid | registrations] + end) + + %__MODULE__{state | registrations: registrations} + end + + def registrations(%__MODULE__{} = state, message_type) do + all = Map.get(state.registrations, :all, []) + specific = Map.get(state.registrations, message_type, []) + all ++ specific + end + + def registered?(%__MODULE__{} = state, pid) do + state.registrations + |> Map.values() + |> List.flatten() + |> Enum.member?(pid) + end + + def registered?(%__MODULE__{} = state, message_type, pid) do + pid in registrations(state, message_type) + end + + def remove(%__MODULE__{} = state, message_type, pid) do + registrations = + Map.update(state.registrations, message_type, [], &Enum.reject(&1, fn e -> e == pid end)) + + %__MODULE__{state | registrations: registrations} + end + + def remove_all(%__MODULE__{} = state, pid) do + registrations = + Map.new(state.registrations, fn {message, pids} -> + pids = Enum.reject(pids, &(&1 == pid)) + {message, pids} + end) + + %__MODULE__{state | registrations: registrations} + end + end + + alias Forge.Project + + @behaviour :gen_event + + def register_message(listener_pid, message_types) do + {:register, listener_pid, message_types} + end + + def registered_message(pid) do + {:registered?, pid} + end + + @impl :gen_event + def init(_) do + {:ok, State.new()} + end + + @impl :gen_event + def handle_call({:register, listener_pid, message_types}, %State{} = state) do + Process.monitor(listener_pid) + + new_state = + Enum.reduce(message_types, state, fn + message_type_or_message, %State{} = state -> + message_type = extract_message_type(message_type_or_message) + State.add(state, message_type, listener_pid) + end) + + {:ok, :ok, new_state} + end + + @impl :gen_event + def handle_call({:registered?, pid}, %State{} = state) do + registered? = State.registered?(state, pid) + {:ok, registered?, state} + end + + @impl :gen_event + def handle_info({:DOWN, _ref, _, pid, _}, %State{} = state) do + new_state = State.remove_all(state, pid) + {:ok, new_state} + end + + @impl :gen_event + def handle_event(message, %State{} = state) do + message_type = extract_message_type(message) + + state + |> State.registrations(message_type) + |> Enum.each(&send(&1, message)) + + {:ok, state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::dispatch" + end + + # Private api + + defp extract_message_type(message_type) when is_atom(message_type), do: message_type + defp extract_message_type(message_type) when is_tuple(message_type), do: elem(message_type, 0) +end diff --git a/forge/lib/forge/document.ex b/forge/lib/forge/document.ex new file mode 100644 index 00000000..b5a6828b --- /dev/null +++ b/forge/lib/forge/document.ex @@ -0,0 +1,401 @@ +defmodule Forge.Document do + @moduledoc """ + A representation of a LSP text document + + A document is the fundamental data structure of the Forge language server. + All language server documents are represented and backed by documents, which + provide functionality for fetching lines, applying changes, and tracking versions. + """ + alias Forge.Convertible + alias Forge.Document.Edit + alias Forge.Document.Line + alias Forge.Document.Lines + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Math + + import Forge.Document.Line + + require Logger + + alias __MODULE__.Path, as: DocumentPath + + @derive {Inspect, only: [:path, :version, :dirty?, :lines]} + + defstruct [:uri, :language_id, :path, :version, dirty?: false, lines: nil] + + @type version :: non_neg_integer() + @type fragment_position :: Position.t() | Convertible.t() + @type t :: %__MODULE__{ + uri: String.t(), + language_id: String.t(), + version: version(), + dirty?: boolean, + lines: Lines.t(), + path: String.t() + } + + @type change_application_error :: {:error, {:invalid_range, map()}} + + # public + + @doc """ + Creates a new document from a uri or path, the source code + as a binary and the vewrsion. + """ + @spec new(Forge.path() | Forge.uri(), String.t(), version()) :: t + def new(maybe_uri, text, version, language_id \\ nil) do + uri = DocumentPath.ensure_uri(maybe_uri) + path = DocumentPath.from_uri(uri) + + language_id = + if String.ends_with?(path, ".exs") do + "elixir-script" + else + language_id || language_id_from_path(path) + end + + %__MODULE__{ + uri: uri, + version: version, + lines: Lines.new(text), + path: path, + language_id: language_id + } + end + + @doc """ + Returns the number of lines in the document + + This is a constant time operation. + """ + @spec size(t) :: non_neg_integer() + def size(%__MODULE__{} = document) do + Lines.size(document.lines) + end + + @doc """ + Marks the document file as dirty + + This function is mainly used internally by lexical + """ + @spec mark_dirty(t) :: t + def mark_dirty(%__MODULE__{} = document) do + %__MODULE__{document | dirty?: true} + end + + @doc """ + Marks the document file as clean + + This function is mainly used internally by lexical + """ + @spec mark_clean(t) :: t + def mark_clean(%__MODULE__{} = document) do + %__MODULE__{document | dirty?: false} + end + + @doc """ + Get the text at the given line using `fetch` semantics + + Returns `{:ok, text}` if the line exists, and `:error` if it doesn't. The line text is + returned without the line end character(s). + + This is a constant time operation. + """ + @spec fetch_text_at(t, version()) :: {:ok, String.t()} | :error + def fetch_text_at(%__MODULE__{} = document, line_number) do + case fetch_line_at(document, line_number) do + {:ok, line(text: text)} -> {:ok, text} + _ -> :error + end + end + + @doc """ + Get the `Forge>Document.Line` at the given index using `fetch` semantics. + + This function is of limited utility, you probably want `fetch_text_at/2` instead. + """ + @spec fetch_line_at(t, version()) :: {:ok, Line.t()} | :error + def fetch_line_at(%__MODULE__{} = document, line_number) do + case Lines.fetch_line(document.lines, line_number) do + {:ok, line} -> {:ok, line} + _ -> :error + end + end + + @doc """ + Returns a fragment defined by the from and to arguments + + Builds a string that represents the text of the document from the two positions given. + The from position, defaults to `:beginning` meaning the start of the document. + Positions can be a `Document.Position.t` or anything that will convert to a position using + `Forge.Convertible.to_native/2`. + """ + @spec fragment(t, fragment_position() | :beginning, fragment_position()) :: String.t() + @spec fragment(t, fragment_position()) :: String.t() + def fragment(%__MODULE__{} = document, from \\ :beginning, to) do + line_count = size(document) + from_pos = convert_fragment_position(document, from) + to_pos = convert_fragment_position(document, to) + + from_line = Math.clamp(from_pos.line, document.lines.starting_index, line_count) + to_line = Math.clamp(to_pos.line, from_line, line_count + 1) + + # source code positions are 1 based, but string slices are zero-based. Need an ad-hoc conversion + # here. + from_character = from_pos.character - 1 + to_character = to_pos.character - 1 + + line_range = from_line..to_line + + line_range + |> Enum.reduce([], fn line_number, acc -> + to_append = + case fetch_line_at(document, line_number) do + {:ok, line(text: text, ending: ending)} -> + line_text = text <> ending + + cond do + line_number == from_line and line_number == to_line -> + slice_length = to_character - from_character + String.slice(line_text, from_character, slice_length) + + line_number == from_line -> + slice_length = String.length(line_text) - from_character + String.slice(line_text, from_character, slice_length) + + line_number == to_line -> + String.slice(line_text, 0, to_character) + + true -> + line_text + end + + :error -> + [] + end + + [acc, to_append] + end) + |> IO.iodata_to_binary() + end + + @doc false + @spec apply_content_changes(t, version(), [Convertible.t() | nil]) :: + {:ok, t} | change_application_error() + def apply_content_changes(%__MODULE__{version: current_version}, new_version, _) + when new_version <= current_version do + {:error, :invalid_version} + end + + def apply_content_changes(%__MODULE__{} = document, _, []) do + {:ok, document} + end + + def apply_content_changes(%__MODULE__{} = document, version, changes) when is_list(changes) do + result = + Enum.reduce_while(changes, document, fn + nil, document -> + {:cont, document} + + change, document -> + case apply_change(document, change) do + {:ok, new_document} -> + {:cont, new_document} + + error -> + {:halt, error} + end + end) + + case result do + %__MODULE__{} = document -> + document = mark_dirty(%__MODULE__{document | version: version}) + + {:ok, document} + + error -> + error + end + end + + @doc """ + Converts a document to a string + + This function converts the given document back into a string, with line endings + preserved. + """ + def to_string(%__MODULE__{} = document) do + document + |> to_iodata() + |> IO.iodata_to_binary() + end + + @spec language_id_from_path(Forge.path()) :: String.t() + defp language_id_from_path(path) do + case Path.extname(path) do + ".ex" -> + "elixir" + + ".exs" -> + "elixir-script" + + ".eex" -> + "eex" + + ".heex" -> + "phoenix-heex" + + extension -> + Logger.warning("can't infer lang ID for #{path}, ext: #{extension}.") + + "unsupported (#{extension})" + end + end + + # private + + defp line_count(%__MODULE__{} = document) do + Lines.size(document.lines) + end + + defp apply_change( + %__MODULE__{} = document, + %Range{start: %Position{} = start_pos, end: %Position{} = end_pos}, + new_text + ) do + start_line = start_pos.line + + new_lines_iodata = + cond do + start_line > line_count(document) -> + append_to_end(document, new_text) + + start_line < 1 -> + prepend_to_beginning(document, new_text) + + true -> + apply_valid_edits(document, new_text, start_pos, end_pos) + end + + new_document = + new_lines_iodata + |> IO.iodata_to_binary() + |> Lines.new() + + {:ok, %__MODULE__{document | lines: new_document}} + end + + defp apply_change(%__MODULE__{} = document, %Edit{range: nil} = edit) do + {:ok, %__MODULE__{document | lines: Lines.new(edit.text)}} + end + + defp apply_change(%__MODULE__{} = document, %Edit{range: %Range{}} = edit) do + if valid_edit?(edit) do + apply_change(document, edit.range, edit.text) + else + {:error, {:invalid_range, edit.range}} + end + end + + defp apply_change(%__MODULE__{} = document, %{range: range, text: text}) do + with {:ok, native_range} <- Convertible.to_native(range, document) do + apply_change(document, Edit.new(text, native_range)) + end + end + + defp apply_change(%__MODULE__{} = document, convertable_edit) do + with {:ok, edit} <- Convertible.to_native(convertable_edit, document) do + apply_change(document, edit) + end + end + + defp valid_edit?(%Edit{ + range: %Range{start: %Position{} = start_pos, end: %Position{} = end_pos} + }) do + start_pos.line >= 0 and start_pos.character >= 0 and end_pos.line >= 0 and + end_pos.character >= 0 + end + + defp append_to_end(%__MODULE__{} = document, edit_text) do + [to_iodata(document), edit_text] + end + + defp prepend_to_beginning(%__MODULE__{} = document, edit_text) do + [edit_text, to_iodata(document)] + end + + defp apply_valid_edits(%__MODULE__{} = document, edit_text, start_pos, end_pos) do + Lines.reduce(document.lines, [], fn line() = line, acc -> + case edit_action(line, edit_text, start_pos, end_pos) do + :drop -> + acc + + {:append, io_data} -> + [acc, io_data] + end + end) + end + + defp edit_action(line() = line, edit_text, %Position{} = start_pos, %Position{} = end_pos) do + %Position{line: start_line, character: start_char} = start_pos + %Position{line: end_line, character: end_char} = end_pos + + line(line_number: line_number, text: text, ending: ending) = line + + cond do + line_number < start_line -> + {:append, [text, ending]} + + line_number > end_line -> + {:append, [text, ending]} + + line_number == start_line && line_number == end_line -> + prefix_text = utf8_prefix(line, start_char) + suffix_text = utf8_suffix(line, end_char) + {:append, [prefix_text, edit_text, suffix_text, ending]} + + line_number == start_line -> + prefix_text = utf8_prefix(line, start_char) + {:append, [prefix_text, edit_text]} + + line_number == end_line -> + suffix_text = utf8_suffix(line, end_char) + {:append, [suffix_text, ending]} + + true -> + :drop + end + end + + defp utf8_prefix(line(text: text), start_code_unit) do + length = max(0, start_code_unit - 1) + binary_part(text, 0, length) + end + + defp utf8_suffix(line(text: text), start_code_unit) do + byte_count = byte_size(text) + start_index = min(start_code_unit - 1, byte_count) + length = byte_count - start_index + + binary_part(text, start_index, length) + end + + defp to_iodata(%__MODULE__{} = document) do + Lines.to_iodata(document.lines) + end + + @spec convert_fragment_position(t, Position.t() | :beginning | Convertible.t()) :: Position.t() + defp convert_fragment_position(%__MODULE__{}, %Position{} = pos) do + pos + end + + defp convert_fragment_position(%__MODULE__{} = document, :beginning) do + Position.new(document, 1, 1) + end + + defp convert_fragment_position(%__MODULE__{} = document, convertible) do + {:ok, %Position{} = converted} = Convertible.to_native(convertible, document) + converted + end +end diff --git a/forge/lib/forge/document/changes.ex b/forge/lib/forge/document/changes.ex new file mode 100644 index 00000000..2911dd80 --- /dev/null +++ b/forge/lib/forge/document/changes.ex @@ -0,0 +1,31 @@ +defmodule Forge.Document.Changes do + @moduledoc """ + A `Forge.Document.Container` for text edits. + + This struct is helpful if you need to express one or several text edits in an LSP response. + It will convert cleanly into either a single `TextEdit` or a list of `TextEdit`s depending on + whether you passed a single edit or a list of edits. + + Using this struct allows efficient conversions at the language server border, as the document + doesn't have to be looked up (and possibly read off the filesystem) by the language server. + """ + defstruct [:document, :edits] + alias Forge.Document + + use Forge.StructAccess + + @type edits :: Document.Edit.t() | [Document.Edit.t()] + @type t :: %__MODULE__{ + document: Document.t(), + edits: edits + } + + @doc """ + Creates a new Changes struct given a document and edits. + + """ + @spec new(Document.t(), edits()) :: t() + def new(document, edits) do + %__MODULE__{document: document, edits: edits} + end +end diff --git a/forge/lib/forge/document/container.ex b/forge/lib/forge/document/container.ex new file mode 100644 index 00000000..1a9298ad --- /dev/null +++ b/forge/lib/forge/document/container.ex @@ -0,0 +1,49 @@ +defprotocol Forge.Document.Container do + @moduledoc """ + A protocol used to find relevant documents in structs + + When converting positions from lsp formats to native and vice versa, you need the + line of text from the relevant document. However, due to the nature of the protocol + structs, there isn't a single place where the document (or a reference) to the document + sits. This protocol allows generic access to the relevant document regardless of the + structure. + + Note: This protocol only needs to be implemented for structs that don't have a `document` + field, or don't have a `text_document` field with a `uri` sub-field. The following structs + would _not_ need an implementation: + + ``` + %MyStruct{document: %Forge.Document{}} + %MyStruct{text_document: %{uri: "file:///path/to/document.ex"}} + ``` + """ + alias Forge.Document + @fallback_to_any true + @type maybe_context_document :: Document.t() | nil + + @spec context_document(t, maybe_context_document()) :: maybe_context_document() + def context_document(t, parent_context_document) +end + +defimpl Forge.Document.Container, for: Any do + alias Forge.Document + + def context_document(%{document: %Document{} = document}, _) do + document + end + + def context_document(%{lsp: lsp_request}, parent_context_document) do + context_document(lsp_request, parent_context_document) + end + + def context_document(%{text_document: %{uri: uri}}, parent_context_document) do + case Document.Store.fetch(uri) do + {:ok, document} -> document + _ -> parent_context_document + end + end + + def context_document(_, parent_context_document) do + parent_context_document + end +end diff --git a/forge/lib/forge/document/edit.ex b/forge/lib/forge/document/edit.ex new file mode 100644 index 00000000..545947eb --- /dev/null +++ b/forge/lib/forge/document/edit.ex @@ -0,0 +1,35 @@ +defmodule Forge.Document.Edit do + @moduledoc """ + A change to a document + + A `Forge.Document.Edit` represents a single change to a document. It contains + the new text and a range where the edit applies. + """ + alias Forge.Document.Range + alias Forge.StructAccess + + defstruct [:text, :range] + + @type t :: %__MODULE__{ + text: String.t(), + range: Range.t() | nil + } + + use StructAccess + + @doc "Creates a new edit that replaces all text in the document" + @spec new(String.t(), Range.t() | nil) :: t + @spec new(String.t()) :: t + def new(text) when is_binary(text) do + %__MODULE__{text: text} + end + + @doc "Creates a new edit that replaces text in the given range" + def new(text, %Range{} = range) do + %__MODULE__{text: text, range: range} + end + + def new(text, nil) when is_binary(text) do + %__MODULE__{text: text} + end +end diff --git a/forge/lib/forge/document/line.ex b/forge/lib/forge/document/line.ex new file mode 100644 index 00000000..8d9ea409 --- /dev/null +++ b/forge/lib/forge/document/line.ex @@ -0,0 +1,30 @@ +defmodule Forge.Document.Line do + @moduledoc ~S""" + A record representing a line of text in a document + + A line contains the following keys: + + `text`: The actual text of the line, without the line ending + + `ending`: The end of line character(s) can be `"\n"`, `"\r"` or `"\r\n"`. The original + line ending is preserved + + `line_number`: A zero-based line number + + `ascii?`: A boolean representing if this line consists of only ascii text. + """ + import Record + + @doc """ + Creates or matches a line of text + """ + defrecord :line, text: nil, ending: nil, line_number: 0, ascii?: true + + @type t :: + record(:line, + text: String.t(), + ending: String.t(), + line_number: non_neg_integer, + ascii?: boolean + ) +end diff --git a/forge/lib/forge/document/line_parser.ex b/forge/lib/forge/document/line_parser.ex new file mode 100644 index 00000000..575d4711 --- /dev/null +++ b/forge/lib/forge/document/line_parser.ex @@ -0,0 +1,109 @@ +defmodule Forge.Document.LineParser do + @moduledoc """ + A parser that parses a binary into `Forge.Document.Line` records. + + The approach taken by the parser is to first go through the binary to find out where + the lines break, what their endings are and if the line is ascii. As we go through the + binary, we store this information, and when we're done, go back and split up the binary + using `binary_slice`. This performs 3x faster than iterating through the binary and collecting + IOlists that represent each line. + + I determines if a line is ascii (and what it really means is utf8 ascii) by checking to see if + each byte is greater than 0 and less than 128. UTF-16 files won't be marked as ascii, which + allows us to skip a lot of byte conversions later in the process. + """ + import Forge.Document.Line + + # it's important that "\r\n" comes before \r here, otherwise the generated pattern + # matches won't match. + @endings ["\r\n", "\r", "\n"] + @max_ascii_character 127 + + @doc """ + Parses the text into lines + + Parses the given text into lines, and uses `starting_index` as the first line's line number. + Passing 0 as starting_index yields a zero-based collection, while passing 1 yields a 1-based + collection. + """ + def parse(text, starting_index) do + text + |> traverse(starting_index) + |> Enum.reduce([], fn index, acc -> [extract_line(text, index) | acc] end) + end + + defp extract_line(text, {line_number, start, stop, is_ascii?, ending}) do + line_text = binary_part(text, start, stop) + line(line_number: line_number, text: line_text, ascii?: is_ascii?, ending: ending) + end + + defp traverse(text, starting_index) do + traverse(text, 0, starting_index, 0, true, []) + end + + for ending <- @endings, + ending_length = byte_size(ending) do + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + line_length = current_index - line_start_index + line_index = {line_number, line_start_index, line_length, is_ascii?, unquote(ending)} + [line_index | acc] + end + + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + line_length = current_index - line_start_index + + acc = [{line_number, line_start_index, line_length, is_ascii?, unquote(ending)} | acc] + next_index = current_index + unquote(ending_length) + traverse(rest, next_index, line_number + 1, next_index, is_ascii?, acc) + end + end + + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + # Note, this heuristic assumes the NUL character won't occur in elixir source files. + # if this isn't true, then we need a better heuristic for detecting utf16 text. + is_still_ascii? = is_ascii? and c <= @max_ascii_character and c > 0 + + traverse( + rest, + current_index + 1, + line_number, + line_start_index, + is_still_ascii?, + acc + ) + end + + defp traverse(<<>>, same_index, _line_number, same_index, _is_ascii, acc) do + # this is a line at the end of the document with no content + # I'm choosing not to represent it as a line to simplify things + # and to make the line count what we expect + acc + end + + defp traverse(<<>>, current_index, line_number, line_start_index, is_ascii?, acc) do + # file doesn't end with a newline + line_length = current_index - line_start_index + [{line_number, line_start_index, line_length, is_ascii?, ""} | acc] + end +end diff --git a/forge/lib/forge/document/lines.ex b/forge/lib/forge/document/lines.ex new file mode 100644 index 00000000..43126ee6 --- /dev/null +++ b/forge/lib/forge/document/lines.ex @@ -0,0 +1,175 @@ +defmodule Forge.Document.Lines do + @moduledoc """ + A hyper-optimized, line-based backing store for text documents + """ + alias Forge.Document.Line + alias Forge.Document.LineParser + + use Forge.StructAccess + import Line + + @default_starting_index 1 + + defstruct lines: nil, starting_index: @default_starting_index + + @type t :: %__MODULE__{} + + @doc """ + Create a new line store with the given text at the given starting index + """ + @spec new(String.t(), non_neg_integer) :: t + def new(text, starting_index \\ @default_starting_index) do + lines = + text + |> LineParser.parse(starting_index) + |> List.to_tuple() + + %__MODULE__{lines: lines, starting_index: starting_index} + end + + @doc """ + Turnss a line store into an iolist + """ + @spec to_iodata(t) :: iodata() + def to_iodata(%__MODULE__{} = document) do + reduce(document, [], fn line(text: text, ending: ending), acc -> + [acc | [text | ending]] + end) + end + + @doc """ + Turns a line store into a string + """ + def to_string(%__MODULE__{} = document) do + document + |> to_iodata() + |> IO.iodata_to_binary() + end + + @doc """ + Returns the number of lines in the line store + """ + def size(%__MODULE__{} = document) do + tuple_size(document.lines) + end + + @doc """ + Gets the current line with the given index using fetch semantics + """ + def fetch_line(%__MODULE__{lines: lines, starting_index: starting_index}, index) + when index - starting_index >= tuple_size(lines) or index < starting_index do + :error + end + + def fetch_line(%__MODULE__{lines: {}}, _) do + :error + end + + def fetch_line(%__MODULE__{} = document, index) when is_integer(index) do + case elem(document.lines, index - document.starting_index) do + line() = line -> {:ok, line} + _ -> :error + end + end + + @doc false + def reduce(%__MODULE__{} = document, initial, reducer_fn) do + size = size(document) + + if size == 0 do + initial + else + Enum.reduce(0..(size - 1), initial, fn index, acc -> + document.lines + |> elem(index) + |> reducer_fn.(acc) + end) + end + end +end + +defimpl Inspect, for: Forge.Document.Lines do + alias Forge.Document.Lines + alias Forge.Document.Line + + import Inspect.Algebra + import Line + + def inspect(%Lines{lines: {}}) do + concat([empty(), "%Lines"]) + end + + def inspect(document, opts) do + document_body = + case Lines.fetch_line(document, 1) do + {:ok, line(text: text)} -> + concat(empty(), to_doc(text <> "...", opts)) + + :error -> + " empty " + end + + line_or_lines = + if Lines.size(document) == 1 do + "line" + else + "lines" + end + + concat([ + empty(), + "%Lines<", + document_body, + "(", + space( + to_doc(Lines.size(document), opts), + line_or_lines + ), + ")>" + ]) + end +end + +defimpl Enumerable, for: Forge.Document.Lines do + alias Forge.Document.Lines + + def count(%Lines{} = document) do + {:ok, Lines.size(document)} + end + + def member?(%Lines{}, _) do + {:error, Lines} + end + + def reduce(%Lines{} = document, acc, fun) do + tuple_reduce({0, tuple_size(document.lines), document.lines}, acc, fun) + end + + def slice(%Lines{} = document) do + {:ok, Lines.size(document), fn start, len -> do_slice(document, start, len) end} + end + + defp do_slice(%Lines{} = document, start, 1) do + [elem(document.lines, start)] + end + + defp do_slice(%Lines{} = document, start, length) do + Enum.map(start..(start + length - 1), &elem(document.lines, &1)) + end + + defp tuple_reduce(_, {:halt, acc}, _fun) do + {:halted, acc} + end + + defp tuple_reduce(current_state, {:suspend, acc}, fun) do + {:suspended, acc, &tuple_reduce(current_state, &1, fun)} + end + + defp tuple_reduce({same, same, _}, {:cont, acc}, _) do + {:done, acc} + end + + defp tuple_reduce({index, size, tuple}, {:cont, acc}, fun) do + tuple_reduce({index + 1, size, tuple}, fun.(elem(tuple, index), acc), fun) + end +end diff --git a/forge/lib/forge/document/location.ex b/forge/lib/forge/document/location.ex new file mode 100644 index 00000000..73d00d55 --- /dev/null +++ b/forge/lib/forge/document/location.ex @@ -0,0 +1,41 @@ +defmodule Forge.Document.Location do + @moduledoc """ + A location in a document + + One of the fundamental LSP structures, this represents a subset of text in a document. + The location is bounded by the given range, and the document can be given as a `Forge.Document` + struct, or a uri referencing the document + """ + alias Forge.Document + alias Forge.Document.Range + + defstruct [:range, :document, :uri] + + @type t :: %__MODULE__{ + range: Range.t(), + document: Document.t() | nil, + uri: Forge.uri() + } + use Forge.StructAccess + + @spec new(Range.t(), Document.t() | String.t()) :: t() + def new(%Range{} = range, %Document{} = document) do + %__MODULE__{range: range, document: document, uri: document.uri} + end + + def new(%Range{} = range, uri) when is_binary(uri) do + %__MODULE__{range: range, uri: uri} + end + + def uri(%__MODULE__{document: %Document{} = document}) do + document.uri + end + + @doc """ + Returns the location document's uri. + """ + @spec uri(t) :: Forge.uri() + def uri(%__MODULE__{} = location) do + location.uri + end +end diff --git a/forge/lib/forge/document/path.ex b/forge/lib/forge/document/path.ex new file mode 100644 index 00000000..f0ecc120 --- /dev/null +++ b/forge/lib/forge/document/path.ex @@ -0,0 +1,148 @@ +defmodule Forge.Document.Path do + @moduledoc """ + A collection of functions dealing with converting filesystem paths to URIs and back + """ + @file_scheme "file" + + @type uri_or_path :: Forge.uri() | Forge.path() + + @doc """ + Given a uri or a path, either return the uri unmodified or converts the path to a uri + """ + @spec ensure_uri(uri_or_path()) :: Forge.uri() + def ensure_uri("file://" <> _ = uri), do: uri + + def ensure_uri("untitled:" <> _ = uri), do: uri + + def ensure_uri(path), do: to_uri(path) + + @doc """ + Given a uri or a path, either return the path unmodified or converts the uri to a path + """ + @spec ensure_path(uri_or_path()) :: Forge.path() + def ensure_path("file://" <> _ = uri), do: from_uri(uri) + + def ensure_path(path) when is_binary(path), do: path + + @doc """ + Returns path from URI in a way that handles windows file:///c%3A/... URLs correctly + """ + def from_uri(%URI{scheme: @file_scheme, path: nil}) do + # treat no path as root path + convert_separators_to_native("/") + end + + def from_uri(%URI{scheme: @file_scheme, path: path, authority: authority}) + when path != "" and authority not in ["", nil] do + # UNC path + convert_separators_to_native("//#{URI.decode(authority)}#{URI.decode(path)}") + end + + def from_uri(%URI{scheme: @file_scheme, path: path}) do + decoded_path = URI.decode(path) + + path = + if windows?() and String.match?(decoded_path, ~r/^\/[a-zA-Z]:/) do + # Windows drive letter path + # drop leading `/` and downcase drive letter + <<"/", letter::binary-size(1), path_rest::binary>> = decoded_path + "#{String.downcase(letter)}#{path_rest}" + else + decoded_path + end + + convert_separators_to_native(path) + end + + # `untitled:` URIs are used for unsaved files in vscode. + def from_uri(%URI{scheme: "untitled"} = uri) when uri.path !== nil do + URI.to_string(uri) + end + + def from_uri(%URI{scheme: scheme}) do + raise ArgumentError, message: "unsupported URI scheme #{inspect(scheme)}" + end + + def from_uri(uri) do + uri |> URI.parse() |> from_uri() + end + + def absolute_from_uri(uri) do + uri |> from_uri() |> Path.absname() + end + + @doc """ + Converts a path into a URI + """ + def to_uri(path) do + path = + path + |> Path.expand() + |> convert_separators_to_universal() + + {authority, path} = + case path do + "//" <> rest -> + # UNC path - extract authority + case String.split(rest, "/", parts: 2) do + [_] -> + # no path part, use root path + {rest, "/"} + + [authority, ""] -> + # empty path part, use root path + {authority, "/"} + + [authority, p] -> + {authority, "/" <> p} + end + + "/" <> _rest -> + {"", path} + + other -> + # treat as relative to root path + {"", "/" <> other} + end + + %URI{ + scheme: @file_scheme, + authority: authority |> URI.encode(), + # file system paths allow reserved URI characters that need to be escaped + # the exact rules are complicated but for simplicity we escape all reserved except `/` + # that's what https://github.com/microsoft/vscode-uri does + path: path |> URI.encode(&(&1 == ?/ or URI.char_unreserved?(&1))) + } + |> URI.to_string() + end + + defp convert_separators_to_native(path) do + if windows?() do + # convert path separators from URI to Windows + String.replace(path, ~r/\//, "\\") + else + path + end + end + + defp convert_separators_to_universal(path) do + if windows?() do + # convert path separators from Windows to URI + String.replace(path, ~r/\\/, "/") + else + path + end + end + + defp windows? do + case os_type() do + {:win32, _} -> true + _ -> false + end + end + + # this is here to be mocked in tests + defp os_type do + :os.type() + end +end diff --git a/forge/lib/forge/document/position.ex b/forge/lib/forge/document/position.ex new file mode 100644 index 00000000..61c7d7b0 --- /dev/null +++ b/forge/lib/forge/document/position.ex @@ -0,0 +1,117 @@ +defmodule Forge.Document.Position do + @moduledoc """ + A position inside of a document + + This struct represents a cursor position inside a document, using one-based line and character + numbers. It's important to note that the position starts before the character given, so positions + are inclusive of the given character. + + Given the following line of text: + "Hello there, welcome to lexical" + + the position: `%Forge.Document.Position{line: 1, character: 1}` starts before the "H" in "Hello" + """ + + alias Forge.Document + alias Forge.Document.Lines + + defstruct [ + :line, + :character, + valid?: false, + context_line: nil, + document_line_count: 0, + starting_index: 1 + ] + + @type line :: non_neg_integer() + @type character :: non_neg_integer() + @type line_container :: Document.t() | Lines.t() + + @type t :: %__MODULE__{ + character: character(), + context_line: Document.Line.t() | nil, + document_line_count: non_neg_integer(), + line: line(), + starting_index: non_neg_integer(), + valid?: boolean() + } + + use Forge.StructAccess + + @spec new(line_container(), line(), character()) :: t + def new(%Document{} = document, line, character) + when is_number(line) and is_number(character) do + new(document.lines, line, character) + end + + def new(%Document.Lines{} = lines, line, character) + when is_number(line) and is_number(character) do + line_count = Document.Lines.size(lines) + starting_index = lines.starting_index + + case Lines.fetch_line(lines, line) do + {:ok, context_line} -> + %__MODULE__{ + character: character, + context_line: context_line, + document_line_count: line_count, + line: line, + starting_index: starting_index, + valid?: true + } + + :error -> + %__MODULE__{ + line: line, + character: character, + document_line_count: line_count, + starting_index: starting_index + } + end + end + + @doc """ + Compares two positions. + + Returns `:gt`, `:lt`, or `:eq` depending on the location of the first + position relative to the second. + """ + @spec compare(t | {line, character}, t | {line, character}) :: :lt | :eq | :gt + def compare(%__MODULE__{} = pos1, %__MODULE__{} = pos2) do + compare({pos1.line, pos1.character}, {pos2.line, pos2.character}) + end + + def compare(%__MODULE__{} = pos1, {_, _} = pos2) do + compare({pos1.line, pos1.character}, pos2) + end + + def compare({_, _} = pos1, %__MODULE__{} = pos2) do + compare(pos1, {pos2.line, pos2.character}) + end + + def compare({l1, c1} = first, {l2, c2} = second) + when is_integer(l1) and is_integer(c1) and is_integer(l2) and is_integer(c2) do + cond do + first < second -> :lt + first > second -> :gt + true -> :eq + end + end +end + +defimpl Inspect, for: Forge.Document.Position do + import Inspect.Algebra + + def inspect(nil, _), do: "nil" + + def inspect(pos, _) do + concat(["LxPos", to_string(pos)]) + end +end + +defimpl String.Chars, for: Forge.Document.Position do + def to_string(pos) do + "<<#{pos.line}, #{pos.character}>>" + end +end diff --git a/forge/lib/forge/document/range.ex b/forge/lib/forge/document/range.ex new file mode 100644 index 00000000..e7fb0075 --- /dev/null +++ b/forge/lib/forge/document/range.ex @@ -0,0 +1,65 @@ +defmodule Forge.Document.Range do + @moduledoc """ + A range in a document + + Note that ranges represent a cursor position, and so are inclusive of + lines, but exclusive of the end position. + + Note: To select an entire line, construct a range that runs from the + first character on the line to the first character on the next line. + + ``` + whole_line = + Range.new( + Position.new(doc, 1, 1), + Position.new(doc, 2, 1) + ) + ``` + """ + alias Forge.Document.Position + + defstruct start: nil, end: nil + + @type t :: %__MODULE__{ + start: Position.t(), + end: Position.t() + } + + use Forge.StructAccess + + @doc """ + Builds a new range. + """ + def new(%Position{} = start_pos, %Position{} = end_pos) do + %__MODULE__{start: start_pos, end: end_pos} + end + + @doc """ + Returns whether the range contains the given position. + """ + def contains?(%__MODULE__{} = range, %Position{} = position) do + %__MODULE__{start: start_pos, end: end_pos} = range + + cond do + position.line == start_pos.line and position.line == end_pos.line -> + position.character >= start_pos.character and position.character <= end_pos.character + + position.line == start_pos.line -> + position.character >= start_pos.character + + position.line == end_pos.line -> + position.character < end_pos.character + + true -> + position.line > start_pos.line and position.line < end_pos.line + end + end +end + +defimpl Inspect, for: Forge.Document.Range do + import Inspect.Algebra + + def inspect(range, _) do + concat(["LxRange[", to_string(range.start), "...", to_string(range.end), "]"]) + end +end diff --git a/forge/lib/forge/document/store.ex b/forge/lib/forge/document/store.ex new file mode 100644 index 00000000..70dfe144 --- /dev/null +++ b/forge/lib/forge/document/store.ex @@ -0,0 +1,423 @@ +defmodule Forge.Document.Store do + @moduledoc """ + Backing store for source file documents. + """ + + alias Forge.Document + alias Forge.ProcessCache + + use GenServer + + @type updater :: (Document.t() -> {:ok, Document.t()} | {:error, any()}) + + @type derivations :: [derivation] + @type derivation :: {derivation_key, derivation_fun} + @type derivation_key :: atom() + @type derivation_fun :: (Document.t() -> derived_value) + @type derived_value :: any() + + @type start_opts :: [start_opt] + @type start_opt :: {:derive, derivations} + + defmodule State do + @moduledoc false + + alias Forge.Document + alias Forge.Document.Store + + require Logger + + import Record + + defstruct open: %{}, temporary_open_refs: %{}, derivation_funs: %{} + + @type t :: %__MODULE__{} + + defrecord :open_doc, document: nil, derived: %{} + + def new(opts \\ []) do + {derivation_funs, invalid} = + opts + |> Keyword.validate!(derive: []) + |> Keyword.fetch!(:derive) + |> Enum.split_with(fn + {atom, fun} when is_atom(atom) and is_function(fun, 1) -> true + _ -> false + end) + + if invalid != [] do + raise ArgumentError, "invalid derive: #{inspect(invalid)}" + end + + %__MODULE__{derivation_funs: Map.new(derivation_funs)} + end + + @spec fetch(t, Forge.uri()) :: {:ok, Document.t(), t} | {:error, :not_open} + def fetch(%__MODULE__{} = store, uri) do + case store.open do + %{^uri => open_doc(document: document)} -> {:ok, document, store} + _ -> {:error, :not_open} + end + end + + @spec fetch(t, Forge.uri(), Store.derivation_key()) :: + {:ok, Document.t(), Store.derived_value(), t} | {:error, :not_open} + def fetch(%__MODULE__{} = store, uri, key) do + case store.open do + %{^uri => open_doc(document: document, derived: %{^key => derivation})} -> + {:ok, document, derivation, store} + + %{^uri => open_doc(document: document, derived: derived)} -> + derivation = derive(store, key, document) + derived = Map.put(derived, key, derivation) + store = put_open_doc(store, document, derived) + {:ok, document, derivation, store} + + _ -> + {:error, :not_open} + end + end + + @spec save(t, Forge.uri()) :: {:ok, t} | {:error, :not_open} + def save(%__MODULE__{} = store, uri) do + case store.open do + %{^uri => open_doc(document: document, derived: derived)} -> + document = Document.mark_clean(document) + store = put_open_doc(store, document, derived) + {:ok, store} + + _ -> + {:error, :not_open} + end + end + + @spec open(t, Forge.uri(), String.t(), pos_integer(), String.t()) :: + {:ok, t} | {:error, :already_open} + def open(%__MODULE__{temporary_open_refs: refs} = store, uri, text, version, language_id) + when is_map_key(refs, uri) do + {_, store} = + store + |> maybe_cancel_ref(uri) + |> pop_open_doc(uri) + + open(store, uri, text, version, language_id) + end + + def open(%__MODULE__{} = store, uri, text, version, language_id) do + case store.open do + %{^uri => _} -> + {:error, :already_open} + + _ -> + document = Document.new(uri, text, version, language_id) + store = put_open_doc(store, document) + {:ok, store} + end + end + + @spec open?(t, Forge.uri()) :: boolean + def open?(%__MODULE__{} = store, uri) do + Map.has_key?(store.open, uri) + end + + @spec close(t, Forge.uri()) :: {:ok, t} | {:error, :not_open} + def close(%__MODULE__{} = store, uri) do + case pop_open_doc(store, uri) do + {nil, _} -> + {:error, :not_open} + + {_, store} -> + {:ok, maybe_cancel_ref(store, uri)} + end + end + + @spec get_and_update(t, Forge.uri(), Store.updater()) :: + {:ok, Document.t(), t} | {:error, any()} + def get_and_update(%__MODULE__{} = store, uri, updater_fn) do + with {:ok, open_doc(document: document)} <- Map.fetch(store.open, uri), + {:ok, document} <- updater_fn.(document) do + {:ok, document, put_open_doc(store, document)} + else + error -> + normalize_error(error) + end + end + + @spec update(t, Forge.uri(), Store.updater()) :: {:ok, t} | {:error, any()} + def update(%__MODULE__{} = store, uri, updater_fn) do + with {:ok, _, store} <- get_and_update(store, uri, updater_fn) do + {:ok, store} + end + end + + @spec open_temporarily(t, Forge.uri() | Path.t(), timeout()) :: + {:ok, Document.t(), t} | {:error, term()} + def open_temporarily(%__MODULE__{} = store, path_or_uri, timeout) do + uri = Document.Path.ensure_uri(path_or_uri) + path = Document.Path.ensure_path(path_or_uri) + + with {:ok, contents} <- File.read(path) do + document = Document.new(uri, contents, 0) + ref = schedule_unload(uri, timeout) + + new_store = + store + |> maybe_cancel_ref(uri) + |> put_ref(uri, ref) + |> put_open_doc(document) + + {:ok, document, new_store} + end + end + + @spec extend_timeout(t, Forge.uri(), timeout()) :: t + def extend_timeout(%__MODULE__{} = store, uri, timeout) do + case store.temporary_open_refs do + %{^uri => ref} -> + Process.cancel_timer(ref) + new_ref = schedule_unload(uri, timeout) + put_ref(store, uri, new_ref) + + _ -> + store + end + end + + @spec unload(t, Forge.uri()) :: t + def unload(%__MODULE__{} = store, uri) do + {_, store} = pop_open_doc(store, uri) + maybe_cancel_ref(store, uri) + end + + defp put_open_doc(%__MODULE__{} = store, %Document{} = document, derived \\ %{}) do + put_in(store.open[document.uri], open_doc(document: document, derived: derived)) + end + + defp pop_open_doc(%__MODULE__{} = store, uri) do + case Map.pop(store.open, uri) do + {open_doc() = doc, open} -> {doc, %__MODULE__{store | open: open}} + {nil, _} -> {nil, store} + end + end + + defp put_ref(%__MODULE__{} = store, uri, ref) do + put_in(store.temporary_open_refs[uri], ref) + end + + defp maybe_cancel_ref(%__MODULE__{} = store, uri) do + case pop_in(store.temporary_open_refs[uri]) do + {ref, store} when is_reference(ref) -> + Process.cancel_timer(ref) + store + + _ -> + store + end + end + + defp schedule_unload(uri, timeout) do + Process.send_after(self(), {:unload, uri}, timeout) + end + + defp normalize_error(:error), do: {:error, :not_open} + defp normalize_error(e), do: e + + defp derive(%__MODULE__{} = store, key, document) do + case store.derivation_funs do + %{^key => fun} -> + fun.(document) + + _ -> + known = Map.keys(store.derivation_funs) + + raise ArgumentError, + "No derivation for #{inspect(key)}, expected one of #{inspect(known)}" + end + end + end + + @spec fetch(Forge.uri()) :: {:ok, Document.t()} | {:error, :not_open} + def fetch(uri) do + GenServer.call(name(), {:fetch, uri}) + end + + @spec fetch(Forge.uri(), derivation_key) :: + {:ok, Document.t(), derived_value} | {:error, :not_open} + def fetch(uri, key) do + GenServer.call(name(), {:fetch, uri, key}) + end + + @spec save(Forge.uri()) :: :ok | {:error, :not_open} + def save(uri) do + GenServer.call(name(), {:save, uri}) + end + + @spec open?(Forge.uri()) :: boolean() + def open?(uri) do + GenServer.call(name(), {:open?, uri}) + end + + @spec open(Forge.uri(), String.t(), String.t(), pos_integer() | nil) :: + :ok | {:error, :already_open} + def open(uri, text, version, language_id \\ nil) do + GenServer.call(name(), {:open, uri, text, version, language_id}) + end + + @spec open_temporary(Forge.uri() | Path.t()) :: + {:ok, Document.t()} | {:error, term()} + + @spec open_temporary(Forge.uri() | Path.t(), timeout()) :: + {:ok, Document.t()} | {:error, term()} + def open_temporary(uri, timeout \\ 5000) when is_binary(uri) do + ProcessCache.trans(uri, 50, fn -> + GenServer.call(name(), {:open_temporarily, uri, timeout}) + end) + end + + @spec close(Forge.uri()) :: :ok | {:error, :not_open} + def close(uri) do + GenServer.call(name(), {:close, uri}) + end + + @spec get_and_update(Forge.uri(), updater) :: {:ok, Document.t()} | {:error, any()} + def get_and_update(uri, update_fn) do + GenServer.call(name(), {:get_and_update, uri, update_fn}) + end + + @spec update(Forge.uri(), updater) :: :ok | {:error, any()} + def update(uri, update_fn) do + GenServer.call(name(), {:update, uri, update_fn}) + end + + @spec start_link(start_opts) :: GenServer.on_start() + def start_link(opts) do + GenServer.start_link(__MODULE__, opts, name: name()) + end + + @impl GenServer + def init(opts) do + {:ok, State.new(opts)} + end + + @impl GenServer + def handle_call({:save, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.save(state, uri) do + {:ok, _} = success -> success + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:open, uri, text, version, language_id}, _from, %State{} = state) do + {reply, new_state} = + case State.open(state, uri, text, version, language_id) do + {:ok, _} = success -> success + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:open?, uri}, _from, %State{} = state) do + reply = State.open?(state, uri) + {:reply, reply, state} + end + + def handle_call({:open_temporarily, uri, timeout_ms}, _, %State{} = state) do + {reply, new_state} = + with {:error, :not_open} <- State.fetch(state, uri), + {:ok, document, new_state} <- State.open_temporarily(state, uri, timeout_ms) do + {{:ok, document}, new_state} + else + {:ok, document, new_state} -> + {{:ok, document}, State.extend_timeout(new_state, uri, timeout_ms)} + + error -> + {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:fetch, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.fetch(state, uri) do + {:ok, value, new_state} -> {{:ok, value}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:fetch, uri, key}, _from, %State{} = state) do + {reply, new_state} = + case State.fetch(state, uri, key) do + {:ok, value, derived_value, new_state} -> {{:ok, value, derived_value}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:close, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.close(state, uri) do + {:ok, new_state} -> {:ok, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:get_and_update, uri, update_fn}, _from, %State{} = state) do + {reply, new_state} = + case State.get_and_update(state, uri, update_fn) do + {:ok, updated_source, new_state} -> {{:ok, updated_source}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:update, uri, updater_fn}, _, %State{} = state) do + {reply, new_state} = + case State.update(state, uri, updater_fn) do + {:ok, new_state} -> {:ok, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + @impl GenServer + def handle_info({:unload, uri}, %State{} = state) do + {:noreply, State.unload(state, uri)} + end + + def set_entropy(entropy) do + :persistent_term.put(entropy_key(), entropy) + entropy + end + + def entropy do + case :persistent_term.get(entropy_key(), :undefined) do + :undefined -> + [:positive] + |> System.unique_integer() + |> set_entropy() + + entropy -> + entropy + end + end + + def name do + {:via, :global, {__MODULE__, entropy()}} + end + + defp entropy_key do + {__MODULE__, :entropy} + end +end diff --git a/forge/lib/forge/formats.ex b/forge/lib/forge/formats.ex new file mode 100644 index 00000000..9cfd6845 --- /dev/null +++ b/forge/lib/forge/formats.ex @@ -0,0 +1,109 @@ +defmodule Forge.Formats do + @moduledoc """ + A collection of formatting functions + """ + + @type unit :: :millisecond | :second + @type time_opt :: {:unit, unit} + @type time_opts :: [time_opt] + + @doc """ + Formats an elapsed time to either seconds or milliseconds + + Examples: + + ``` + Format.seconds(500, unit: :millisecond) + "0.5 seconds" + ``` + + ``` + Format.format(1500, unit: :millisecond) + "1.4 seconds" + ``` + + ``` + Format.format(1500) + "15 ms" + ``` + """ + @spec time(time :: non_neg_integer(), opts :: time_opts) :: String.t() + def time(time, opts \\ []) do + units = Keyword.get(opts, :unit, :microsecond) + millis = to_milliseconds(time, units) + + cond do + millis >= 1000 -> + "#{Float.round(millis / 1000, 1)} seconds" + + millis >= 1.0 -> + "#{trunc(millis)} ms" + + true -> + "#{millis} ms" + end + end + + @doc """ + Formats a name of a module + Both elixir and erlang modules will format like they appear in elixir source code. + + ``` + Format.format(MyModule) + "MyModule" + ``` + + ``` + Formats.module(Somewhat.Nested.Module) + "Somewhat.Nested.Module" + ``` + + ``` + Format.format(:erlang_module) + ":erlang_module" + ``` + """ + @spec module(atom()) :: String.t() + def module(module_name) when is_atom(module_name) do + string_name = Atom.to_string(module_name) + + if String.contains?(string_name, ".") do + case string_name do + "Elixir." <> rest -> rest + other -> other + end + else + # erlang module_name + ":#{string_name}" + end + end + + def module(module_name) when is_binary(module_name) do + module_name + end + + defp to_milliseconds(micros, :microsecond) do + micros / 1000 + end + + defp to_milliseconds(millis, :millisecond) do + millis + end + + def plural(count, singular, plural) do + case count do + 0 -> templatize(count, plural) + 1 -> templatize(count, singular) + _n -> templatize(count, plural) + end + end + + def mfa(module, function, arity) do + "#{module(module)}.#{function}/#{arity}" + end + + defp templatize(count, template) do + count_string = Integer.to_string(count) + String.replace(template, "${count}", count_string) + end +end diff --git a/forge/lib/forge/identifier.ex b/forge/lib/forge/identifier.ex new file mode 100644 index 00000000..79e1464c --- /dev/null +++ b/forge/lib/forge/identifier.ex @@ -0,0 +1,27 @@ +defmodule Forge.Identifier do + @doc """ + Returns the next globally unique identifier. + Raises a MatchError if this cannot be computed. + """ + def next_global! do + {:ok, next_id} = Snowflake.next_id() + next_id + end + + def to_unix(id) do + Snowflake.Util.real_timestamp_of_id(id) + end + + def to_datetime(id) do + id + |> to_unix() + |> DateTime.from_unix!(:millisecond) + end + + def to_erl(id) do + %DateTime{year: year, month: month, day: day, hour: hour, minute: minute, second: second} = + to_datetime(id) + + {{year, month, day}, {hour, minute, second}} + end +end diff --git a/forge/lib/forge/math.ex b/forge/lib/forge/math.ex new file mode 100644 index 00000000..524829c6 --- /dev/null +++ b/forge/lib/forge/math.ex @@ -0,0 +1,19 @@ +defmodule Forge.Math do + @moduledoc """ + Utilities related to mathematical operations + """ + + @doc """ + Clamp the number between `min_number` and `max_number` + + If the first argument is less than `min_number`, then `min_number` is returned. + + If the number given in the first argument is greater than `max_number` then `max_number` is returned. + + Otherwise, the first argument is returned. + """ + def clamp(number, min_number, max_number) + when is_number(number) and is_number(min_number) and is_number(max_number) do + number |> max(min_number) |> min(max_number) + end +end diff --git a/forge/lib/forge/mix.ex b/forge/lib/forge/mix.ex new file mode 100644 index 00000000..85e95f4b --- /dev/null +++ b/forge/lib/forge/mix.ex @@ -0,0 +1,53 @@ +defmodule Forge.Mix do + alias Forge.Project + + def in_project(fun) do + if Forge.project_node?() do + in_project(Forge.get_project(), fun) + else + {:error, :not_project_node} + end + end + + def in_project(%Project{} = project, fun) do + # Locking on the build make sure we don't get a conflict on the mix.exs being + # already defined + + old_cwd = File.cwd!() + + with_lock(fn -> + try do + Mix.ProjectStack.post_config(prune_code_paths: false) + + build_path = Engine.Build.path(project) + project_root = Project.root_path(project) + + project + |> Project.atom_name() + |> Mix.Project.in_project(project_root, [build_path: build_path], fun) + rescue + ex -> + blamed = Exception.blame(:error, ex, __STACKTRACE__) + {:error, {:exception, blamed, __STACKTRACE__}} + else + result -> + case result do + error when is_tuple(error) and elem(error, 0) == :error -> + error + + ok when is_tuple(ok) and elem(ok, 0) == :ok -> + ok + + other -> + {:ok, other} + end + after + File.cd!(old_cwd) + end + end) + end + + defp with_lock(fun) do + Engine.with_lock(__MODULE__, fun) + end +end diff --git a/forge/lib/forge/module/loader.ex b/forge/lib/forge/module/loader.ex new file mode 100644 index 00000000..92fa930b --- /dev/null +++ b/forge/lib/forge/module/loader.ex @@ -0,0 +1,43 @@ +defmodule Forge.Module.Loader do + @moduledoc """ + Apparently, Code.ensure_loaded?/1 is pretty slow. I'm guessing because it has to do a + round trip to the code server for each check. This in turn slows down indexing, so the thought + is that having a cache will improve performance + """ + + alias Future.Code + use Agent + + def start_link(_) do + initialize = fn -> + Map.new(:code.all_loaded(), fn {name, _} -> {:module, name} end) + end + + Agent.start_link(initialize, name: __MODULE__) + end + + def ensure_loaded(module_name) do + Agent.get_and_update(__MODULE__, fn + %{^module_name => result} = state -> + {result, state} + + state -> + result = Code.ensure_loaded(module_name) + {result, Map.put(state, module_name, result)} + end) + end + + def ensure_loaded?(module_name) do + match?({:module, ^module_name}, ensure_loaded(module_name)) + end + + def loaded?(module_name) do + Agent.get(__MODULE__, fn + %{^module_name => {:module, _}} -> + true + + _ -> + false + end) + end +end diff --git a/forge/lib/forge/modules.ex b/forge/lib/forge/modules.ex new file mode 100644 index 00000000..def6a9f6 --- /dev/null +++ b/forge/lib/forge/modules.ex @@ -0,0 +1,255 @@ +defmodule Forge.Modules do + @moduledoc """ + Utilities for dealing with modules on the remote control node + """ + + alias Future.Code.Typespec + alias Forge.Module.Loader + + @typedoc "Module documentation record as defined by EEP-48" + @type docs_v1 :: tuple() + + @typedoc "A type, spec, or callback definition" + @type definition :: + {name :: atom(), arity :: arity(), formatted :: String.t(), quoted :: Macro.t()} + + @cache_timeout Application.compile_env(:remote_control, :modules_cache_expiry, {10, :second}) + + @doc """ + Ensure the given module is compiled, returning the BEAM object code if successful. + """ + @spec ensure_beam(module()) :: + {:ok, beam :: binary()} | {:error, reason} + when reason: + :embedded + | :badfile + | :nofile + | :on_load_failure + | :unavailable + | :get_object_code_failed + def ensure_beam(module) when is_atom(module) do + with {:module, _} <- Code.ensure_compiled(module), + {_module, beam, _filename} <- :code.get_object_code(module) do + {:ok, beam} + else + :error -> {:error, :get_object_code_failed} + {:error, error} -> {:error, error} + end + end + + @doc """ + Fetch the docs chunk from BEAM object code. + """ + @spec fetch_docs(beam :: binary()) :: {:ok, docs_v1()} | :error + @docs_chunk ~c"Docs" + def fetch_docs(beam) when is_binary(beam) do + case :beam_lib.chunks(beam, [@docs_chunk]) do + {:ok, {_module, [{@docs_chunk, bin}]}} -> + {:ok, :erlang.binary_to_term(bin)} + + _ -> + :error + end + end + + @doc """ + Fetch the specs from BEAM object code. + """ + @spec fetch_specs(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_specs(beam) when is_binary(beam) do + case Typespec.fetch_specs(beam) do + {:ok, specs} -> + defs = + for {{name, arity}, defs} <- specs, + def <- defs do + quoted = Typespec.spec_to_quoted(name, def) + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Fetch the types from BEAM object code. + """ + @spec fetch_types(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_types(beam) when is_binary(beam) do + case Typespec.fetch_types(beam) do + {:ok, types} -> + defs = + for {kind, {name, _body, args} = type} <- types do + arity = length(args) + quoted_type = Typespec.type_to_quoted(type) + quoted = {:@, [], [{kind, [], [quoted_type]}]} + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Fetch the specs from BEAM object code. + """ + @spec fetch_callbacks(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_callbacks(beam) when is_binary(beam) do + case Typespec.fetch_callbacks(beam) do + {:ok, callbacks} -> + defs = + for {{name, arity}, defs} <- callbacks, + def <- defs do + quoted = Typespec.spec_to_quoted(name, def) + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Get a list of a module's functions + + This function will attempt to load the given module using our module cache, and + if it's found, will return a keyword list of function names and arities. + """ + @spec fetch_functions(module()) :: {:ok, [{function(), arity()}]} | :error + def fetch_functions(module) when is_atom(module) do + with {:module, module} <- Loader.ensure_loaded(module) do + cond do + function_exported?(module, :__info__, 1) -> + {:ok, module.__info__(:functions)} + + function_exported?(module, :module_info, 1) -> + {:ok, module.module_info(:functions)} + + true -> + :error + end + end + end + + defp format_definition(quoted) do + quoted + |> Future.Code.quoted_to_algebra() + |> Inspect.Algebra.format(60) + |> IO.iodata_to_binary() + end + + @doc """ + Returns all modules matching a prefix + + `with_prefix` returns all modules on the node on which it runs that start with the given prefix. + It's worth noting that it will return _all modules_ regardless if they have been loaded or not. + + You can optionally pass a predicate MFA to further select which modules are returned, but + it's important to understand that the predicate can only be a function reference to a function that + exists on the `remote_control` node. I.e. you CANNOT pass anonymous functions to this module. + + Each module will be added as the first argument to the given list of args in the predicate, + for example: + + iex> Modules.with_prefix("Gen", {Kernel, :macro_exported?, [:__using__, 1]}) + [GenEvent, GenServer] + + """ + def with_prefix(prefix_module, predicate_mfa \\ {Function, :identity, []}) + + def with_prefix(prefix_module, mfa) when is_atom(prefix_module) do + prefix_module + |> to_string() + |> with_prefix(mfa) + end + + def with_prefix("Elixir." <> _ = prefix, mfa) do + results = + for {module_string, already_loaded?} <- all_modules(), + String.starts_with?(module_string, prefix), + module = Module.concat([module_string]), + ensure_loaded?(module, already_loaded?), + apply_predicate(module, mfa) do + {module_string, module} + end + + {module_strings, modules_with_prefix} = Enum.unzip(results) + + mark_loaded(module_strings) + + modules_with_prefix + end + + def with_prefix(prefix, mfa) do + with_prefix("Elixir." <> prefix, mfa) + end + + defp apply_predicate(module_arg, {invoked_module, function, args}) do + apply(invoked_module, function, [module_arg | args]) + end + + defp ensure_loaded?(_, true), do: true + defp ensure_loaded?(module, _), do: Loader.ensure_loaded?(module) + + defp mark_loaded(modules) when is_list(modules) do + newly_loaded = Map.new(modules, &{&1, true}) + {expires, all_loaded} = :persistent_term.get(__MODULE__) + updated = Map.merge(all_loaded, newly_loaded) + + :persistent_term.put(__MODULE__, {expires, updated}) + end + + defp all_modules do + case term() do + {:ok, modules} -> + modules + + :error -> + {_expires, modules} = cache = rebuild_cache() + :persistent_term.put(__MODULE__, cache) + modules + end + end + + defp term do + {expires_at, modules} = :persistent_term.get(__MODULE__, {nil, []}) + + if expired?(expires_at) do + :error + else + {:ok, modules} + end + end + + defp expired?(nil), do: true + + defp expired?(expires) do + DateTime.compare(DateTime.utc_now(), expires) == :gt + end + + defp rebuild_cache do + {amount, unit} = @cache_timeout + + expires = DateTime.add(DateTime.utc_now(), amount, unit) + + module_map = + Map.new(:code.all_available(), fn {module_charlist, _path, already_loaded?} -> + {to_string(module_charlist), already_loaded?} + end) + + {expires, module_map} + end +end diff --git a/forge/lib/forge/plugin/v1/diagnostic/result.ex b/forge/lib/forge/plugin/v1/diagnostic/result.ex new file mode 100644 index 00000000..a0cd687c --- /dev/null +++ b/forge/lib/forge/plugin/v1/diagnostic/result.ex @@ -0,0 +1,105 @@ +defmodule Forge.Plugin.V1.Diagnostic.Result do + @moduledoc """ + The result of a diagnostic run + + A diagnostic plugin emits a list of `Result` structs that inform the user about issues + the plugin has found. The results contain the following keys: + + `uri` - The URI of the document where the error occurs. `Forge.Document` structs contain a + `uri` field which can be used to fill out this field. If you have a filesystem path, the function + `Forge.Document.Path.to_uri/1` can be used to transform a path to a URI. + + `message` - The diagnostic message displayed to the user + + `details` - Further details about the message + + `position` - Where the message occurred (see the `Positions` section for details) + + `severity` - How important the issue is. Can be one of (from least severe to most severe) + `:hint`, `:information`, `:warning`, `:error` + + `source` - The name of the plugin that produced this as a human-readable string. + + + ## Positions + + Diagnostics need to inform the language client where the error occurs. Positions are the + mechanism they use to do so. Positions take several forms, which are: + + `line number` - If the position is a one-based line number, the diagnostic will refer to + the entire flagged line + + `{line_number, column}` - If the position is a two-tuple of a one-based line number and a one-based + column, then the diagnostic will begin on the line indicated, and start at the column indicated. The + diagnostic will run to the end of the line. + + `{start_line, start_column, end_line, end_column}` - If the position is a four-tuple of of one-based + line and column numbers, the diagnostic will start on `start_line` at `start_column` and run until + `end_line` at `end_column`. This is the most detailed form of describing a position, and should be preferred + to the others, as it will produce the most accurate highlighting of the diagnostic. + + `Document.Range.t` - Equivalent to the {start_line, start_column, end_line, end_column}, but saves a + conversion step + + `Document.Position.t` - Equivalent to `{line_number, column}`, but saves a conversion step. + """ + alias Forge.Document + defstruct [:details, :message, :position, :severity, :source, :uri] + + @typedoc """ + A path or a uri. + """ + @type path_or_uri :: Forge.path() | Forge.uri() + + @typedoc """ + The severity of the diagnostic. + """ + @type severity :: :hint | :information | :warning | :error + + @typedoc false + @type mix_position :: + non_neg_integer() + | {pos_integer(), non_neg_integer()} + | {pos_integer(), non_neg_integer(), pos_integer(), non_neg_integer()} + + @typedoc """ + Where the error occurs in the document. + """ + @type position :: mix_position() | Document.Range.t() | Document.Position.t() + + @typedoc """ + A result emitted by a diagnostic plugin. + + These results are displayed in the editor to the user. + """ + @type t :: %__MODULE__{ + position: position, + message: iodata(), + severity: severity(), + source: String.t(), + uri: Forge.uri() + } + + @doc """ + Creates a new diagnostic result. + """ + @spec new(path_or_uri, position, iodata(), severity(), String.t()) :: t + @spec new(path_or_uri, position, iodata(), severity(), String.t(), any()) :: t + def new(maybe_uri_or_path, position, message, severity, source, details \\ nil) do + uri = + if maybe_uri_or_path do + Document.Path.ensure_uri(maybe_uri_or_path) + end + + message = IO.iodata_to_binary(message) + + %__MODULE__{ + uri: uri, + position: position, + message: message, + source: source, + severity: severity, + details: details + } + end +end diff --git a/forge/lib/forge/process_cache.ex b/forge/lib/forge/process_cache.ex new file mode 100644 index 00000000..69d02890 --- /dev/null +++ b/forge/lib/forge/process_cache.ex @@ -0,0 +1,116 @@ +defmodule Forge.ProcessCache do + @moduledoc """ + A simple cache with a timeout that lives in the process dictionary + """ + + defmodule Entry do + @moduledoc false + + defstruct [:value, :expiry] + + def new(value, timeout_ms) do + expiry_ts = now_ts() + timeout_ms + %__MODULE__{value: value, expiry: expiry_ts} + end + + def valid?(%__MODULE__{} = entry) do + now_ts() < entry.expiry + end + + defp now_ts do + System.os_time(:millisecond) + end + end + + @type key :: term() + @type fetch_result :: {:ok, term()} | :error + + @doc """ + Retrieves a value from the cache + If the value is not found, the default is returned + """ + @spec get(key()) :: term() | nil + @spec get(key(), term()) :: term() | nil + def get(key, default \\ nil) do + case fetch(key) do + {:ok, val} -> val + :error -> default + end + end + + @doc """ + Retrieves a value from the cache + If the value is not found, the default is returned + """ + @spec fetch(key()) :: fetch_result() + def fetch(key) do + case Process.get(key, :unset) do + %Entry{} = entry -> + if Entry.valid?(entry) do + {:ok, entry.value} + else + Process.delete(key) + :error + end + + :unset -> + :error + end + end + + def clear_keys do + keys() + |> MapSet.put(all_keys_key()) + |> Enum.each(&Process.delete/1) + end + + @doc """ + Retrieves and optionally sets a value in the cache. + + Trans looks up a value in the cache under key. If that value isn't + found, the compute_fn is then executed, and its return value is set + in the cache. The cached value will live in the cache for `timeout` + milliseconds + """ + def trans(key, timeout_ms \\ 5000, compute_fn) do + case fetch(key) do + :error -> + set(key, timeout_ms, compute_fn) + + {:ok, result} -> + result + end + end + + defmacro with_cleanup(do: block) do + quote do + try do + unquote(block) + after + unquote(__MODULE__).clear_keys() + end + end + end + + defp set(key, timeout_ms, compute_fn) do + value = compute_fn.() + + add_key(key) + Process.put(key, Entry.new(value, timeout_ms)) + + value + end + + defp add_key(key) do + updated_keys = MapSet.put(keys(), key) + Process.put(all_keys_key(), updated_keys) + end + + defp all_keys_key do + {__MODULE__, :all_keys} + end + + defp keys do + Process.get(all_keys_key(), MapSet.new()) + end +end diff --git a/forge/lib/forge/project.ex b/forge/lib/forge/project.ex new file mode 100644 index 00000000..38c947b5 --- /dev/null +++ b/forge/lib/forge/project.ex @@ -0,0 +1,324 @@ +defmodule Forge.Project do + @moduledoc """ + The representation of the current state of an elixir project. + + This struct contains all the information required to build a project and interrogate its configuration, + as well as business logic for how to change its attributes. + """ + alias Forge.Document + + defstruct root_uri: nil, + mix_exs_uri: nil, + mix_project?: false, + mix_env: nil, + mix_target: nil, + env_variables: %{}, + project_module: nil, + entropy: 1 + + @type message :: String.t() + @type restart_notification :: {:restart, Logger.level(), String.t()} + @type t :: %__MODULE__{ + root_uri: Forge.uri() | nil, + mix_exs_uri: Forge.uri() | nil, + entropy: non_neg_integer() + # mix_env: atom(), + # mix_target: atom(), + # env_variables: %{String.t() => String.t()} + } + @type error_with_message :: {:error, message} + + @workspace_directory_name ".expert-lsp" + + # Public + @spec new(Forge.uri()) :: t + def new(root_uri) do + entropy = :rand.uniform(65_536) + + %__MODULE__{entropy: entropy} + |> maybe_set_root_uri(root_uri) + |> maybe_set_mix_exs_uri() + end + + @spec set_project_module(t(), module() | nil) :: t() + def set_project_module(%__MODULE__{} = project, nil) do + project + end + + def set_project_module(%__MODULE__{} = project, module) when is_atom(module) do + %__MODULE__{project | project_module: module} + end + + @doc """ + Retrieves the name of the project + """ + @spec name(t) :: String.t() + + def name(%__MODULE__{} = project) do + sanitized = + project + |> folder_name() + |> String.replace(~r/[^a-zA-Z0-9_]/, "_") + + # This might be a litte verbose, but this code is hot. + case sanitized do + <> when c in ?a..?z -> + sanitized + + <> when c in ?A..?Z -> + String.downcase("#{[c]}") <> rest + + other -> + "p_#{other}" + end + end + + @doc """ + The project node's name + """ + def node_name(%__MODULE__{} = project) do + :"project-#{name(project)}-#{entropy(project)}@127.0.0.1" + end + + def entropy(%__MODULE__{} = project) do + project.entropy + end + + def config(%__MODULE__{} = project) do + config_key = {__MODULE__, name(project), :config} + + case :persistent_term.get(config_key, :not_found) do + :not_found -> + config = project.project_module.project() + :persistent_term.put(config_key, config) + config + + config -> + config + end + end + + @doc """ + Returns the the name definied in the `project/0` of mix.exs file + """ + def display_name(%__MODULE__{} = project) do + case config(project) do + [] -> + folder_name(project) + + config -> + Keyword.get(config, :name, folder_name(project)) + end + end + + @doc """ + Retrieves the name of the project as an atom + """ + @spec atom_name(t) :: atom + def atom_name(%__MODULE__{project_module: nil} = project) do + project + |> name() + |> String.to_atom() + end + + def atom_name(%__MODULE__{} = project) do + project.project_module + end + + @doc """ + Returns the full path of the project's root directory + """ + @spec root_path(t) :: Path.t() | nil + def root_path(%__MODULE__{root_uri: nil}) do + nil + end + + def root_path(%__MODULE__{} = project) do + Document.Path.from_uri(project.root_uri) + end + + @spec project_path(t) :: Path.t() | nil + def project_path(%__MODULE__{root_uri: nil}) do + nil + end + + def project_path(%__MODULE__{} = project) do + Document.Path.from_uri(project.root_uri) + end + + @doc """ + Returns the full path to the project's mix.exs file + """ + @spec mix_exs_path(t) :: Path.t() | nil + def mix_exs_path(%__MODULE__{mix_exs_uri: nil}) do + nil + end + + def mix_exs_path(%__MODULE__{mix_exs_uri: mix_exs_uri}) do + Document.Path.from_uri(mix_exs_uri) + end + + @spec change_environment_variables(t, map() | nil) :: + {:ok, t} | error_with_message() | restart_notification() + def change_environment_variables(%__MODULE__{} = project, environment_variables) do + set_env_vars(project, environment_variables) + end + + @doc """ + Returns the full path to the project's lexical workspace directory + + Engine maintains a workspace directory in project it konws about, and places various + artifacts there. This function returns the full path to that directory + """ + @spec workspace_path(t) :: String.t() + def workspace_path(%__MODULE__{} = project) do + project + |> root_path() + |> Path.join(@workspace_directory_name) + end + + @doc """ + Returns the full path to a file in lexical's workspace directory + """ + @spec workspace_path(t, String.t() | [String.t()]) :: String.t() + def workspace_path(%__MODULE__{} = project, relative_path) when is_binary(relative_path) do + workspace_path(project, [relative_path]) + end + + def workspace_path(%__MODULE__{} = project, relative_path) when is_list(relative_path) do + Path.join([workspace_path(project) | relative_path]) + end + + @doc """ + Returns the full path to the directory where lexical puts build artifacts + """ + def build_path(%__MODULE__{} = project) do + project + |> workspace_path() + |> Path.join("build") + end + + @doc """ + Creates and initializes lexical's workspace directory if it doesn't already exist + """ + def ensure_workspace(%__MODULE__{} = project) do + with :ok <- ensure_workspace_directory(project) do + ensure_git_ignore(project) + end + end + + defp ensure_workspace_directory(project) do + workspace_path = workspace_path(project) + + cond do + File.exists?(workspace_path) and File.dir?(workspace_path) -> + :ok + + File.exists?(workspace_path) -> + :ok = File.rm(workspace_path) + :ok = File.mkdir_p(workspace_path) + + true -> + :ok = File.mkdir(workspace_path) + end + end + + defp ensure_git_ignore(project) do + contents = """ + * + """ + + path = workspace_path(project, ".gitignore") + + if File.exists?(path) do + :ok + else + File.write(path, contents) + end + end + + defp maybe_set_root_uri(%__MODULE__{} = project, nil), + do: %__MODULE__{project | root_uri: nil} + + defp maybe_set_root_uri(%__MODULE__{} = project, "file://" <> _ = root_uri) do + root_path = + root_uri + |> Document.Path.absolute_from_uri() + |> Path.expand() + + if File.exists?(root_path) do + expanded_uri = Document.Path.to_uri(root_path) + %__MODULE__{project | root_uri: expanded_uri} + else + project + end + end + + defp maybe_set_mix_exs_uri(%__MODULE__{} = project) do + possible_mix_exs_path = + project + |> root_path() + |> find_mix_exs_path() + + if mix_exs_exists?(possible_mix_exs_path) do + %__MODULE__{ + project + | mix_exs_uri: Document.Path.to_uri(possible_mix_exs_path), + mix_project?: true + } + else + project + end + end + + # Project Path + + # Environment variables + + def set_env_vars(%__MODULE__{} = old_project, %{} = env_vars) do + case {old_project.env_variables, env_vars} do + {nil, vars} when map_size(vars) == 0 -> + {:ok, %__MODULE__{old_project | env_variables: vars}} + + {nil, new_vars} -> + System.put_env(new_vars) + {:ok, %__MODULE__{old_project | env_variables: new_vars}} + + {same, same} -> + {:ok, old_project} + + _ -> + {:restart, :warning, "Environment variables have changed. Engine needs to restart"} + end + end + + def set_env_vars(%__MODULE__{} = old_project, _) do + {:ok, old_project} + end + + defp find_mix_exs_path(nil) do + System.get_env("MIX_EXS") + end + + defp find_mix_exs_path(project_directory) do + case System.get_env("MIX_EXS") do + nil -> + Path.join(project_directory, "mix.exs") + + mix_exs -> + mix_exs + end + end + + defp mix_exs_exists?(nil), do: false + + defp mix_exs_exists?(mix_exs_path) do + File.exists?(mix_exs_path) + end + + defp folder_name(project) do + project + |> root_path() + |> Path.basename() + end +end diff --git a/forge/lib/forge/search/fuzzy.ex b/forge/lib/forge/search/fuzzy.ex new file mode 100644 index 00000000..46e16c19 --- /dev/null +++ b/forge/lib/forge/search/fuzzy.ex @@ -0,0 +1,386 @@ +defmodule Forge.Search.Fuzzy do + @moduledoc """ + A backend for fuzzy matching + + This is a storage module that allows you to map keys to multiple values in two ways. + + Values are grouped by their `subject`, which is a string that enables fuzzy matching. They can also be grouped + by a `grouping key` that allows for grouping by an arbitrary value. + + For both cases, multiple values can exist under the same key, and when searching, all values under the key are + returned. + """ + + alias Forge.Project + + alias Forge.Search.Fuzzy.Scorer + alias Forge.Search.Indexer.Entry + import Record + + defstruct subject_to_values: %{}, + grouping_key_to_values: %{}, + preprocessed_subjects: %{}, + mapper: nil, + filter_fn: nil, + subject_converter: nil + + defrecordp :mapped, + application: nil, + grouping_key: nil, + subject: nil, + subtype: nil, + type: nil, + value: nil + + @type subject :: String.t() + @type extracted_subject :: term() + @type grouping_key :: term() + @type value :: term() + @type extracted_subject_grouping_key_value :: {extracted_subject(), grouping_key(), value()} + @type mapper :: (term -> extracted_subject_grouping_key_value) + @type subject_converter :: (extracted_subject() -> subject()) + + @opaque t :: %__MODULE__{ + subject_to_values: %{subject() => [value()]}, + grouping_key_to_values: %{Path.t() => [value()]}, + preprocessed_subjects: %{subject() => tuple()}, + mapper: mapper(), + subject_converter: subject_converter() + } + + @spec from_entries([Entry.t()]) :: t + def from_entries(entries) do + mapper = default_mapper() + + new(entries, mapper, &stringify/1, true) + end + + def from_backend(backend) do + mapper = default_mapper() + + mapped_items = + backend.reduce([], fn + %Entry{subtype: :definition} = entry, acc -> [mapper.(entry) | acc] + _, acc -> acc + end) + + new(mapped_items, mapper, &stringify/1, false) + end + + @doc """ + Creates a new fuzzy matcher. + + Items in the enumerable first argument will have the mapper function applied to them. + For each tuple returned, the first element will then have the subject converter applied. + This will produce a subject, which is what the `match/2` function uses for fuzzy matching. + """ + @spec new(Enumerable.t(), mapper(), subject_converter(), boolean()) :: t + def new(items, mapper, subject_converter, map_items?) do + filter_fun = build_filter_fn() + + mapped_items = + if map_items? do + items + |> Stream.map(mapper) + |> Enum.filter(filter_fun) + else + Enum.filter(items, filter_fun) + end + + extract_and_fix_subject = fn mapped() = mapped -> subject_converter.(mapped) end + extract_value = fn mapped(value: value) -> value end + + subject_to_values = Enum.group_by(mapped_items, extract_and_fix_subject, extract_value) + + extract_grouping_key = fn mapped(grouping_key: grouping_key) -> grouping_key end + + grouping_key_to_values = Enum.group_by(mapped_items, extract_grouping_key, extract_value) + + preprocessed_subjects = + subject_to_values + |> Map.keys() + |> Map.new(fn subject -> {subject, Scorer.preprocess(subject)} end) + + %__MODULE__{ + filter_fn: filter_fun, + grouping_key_to_values: grouping_key_to_values, + mapper: mapper, + preprocessed_subjects: preprocessed_subjects, + subject_converter: subject_converter, + subject_to_values: subject_to_values + } + end + + @doc """ + Applies fuzzy matching to the pattern. + + Values that match will be aggregated and returned sorted + in descending order of the match relevance. Items at the beginning of the list + will have a higher score than items at the end. + """ + @spec match(t(), String.t()) :: [Entry.entry_id()] + def match(%__MODULE__{} = fuzzy, pattern) do + fuzzy.subject_to_values + |> Stream.map(fn {subject, ids} -> + case score(fuzzy, subject, pattern) do + {:ok, score} -> + {score, ids} + + :error -> + nil + end + end) + |> Stream.reject(&is_nil/1) + |> Enum.sort_by(&elem(&1, 0), :desc) + |> Enum.flat_map(&elem(&1, 1)) + end + + @doc """ + Adds a single item or a list of items to the fuzzy instance. + """ + @spec add(t, term | [term]) :: t + def add(%__MODULE__{} = fuzzy, items) when is_list(items) do + Enum.reduce(items, fuzzy, fn entry, fuzzy -> + add(fuzzy, entry) + end) + end + + def add(%__MODULE__{} = fuzzy, item) do + mapped_item = fuzzy.mapper.(item) + + if fuzzy.filter_fn.(mapped_item) do + subject = fuzzy.subject_converter.(mapped_item) + mapped(grouping_key: grouping_key, value: value) = mapped_item + + updated_grouping_key_to_values = + Map.update(fuzzy.grouping_key_to_values, grouping_key, [value], fn old_ids -> + [value | old_ids] + end) + + updated_subject_to_values = + Map.update(fuzzy.subject_to_values, subject, [value], fn old_ids -> + [value | old_ids] + end) + + updated_preprocessed_subjects = + Map.put_new_lazy(fuzzy.preprocessed_subjects, subject, fn -> + Scorer.preprocess(subject) + end) + + %__MODULE__{ + fuzzy + | grouping_key_to_values: updated_grouping_key_to_values, + subject_to_values: updated_subject_to_values, + preprocessed_subjects: updated_preprocessed_subjects + } + else + fuzzy + end + end + + @doc """ + Returns true if the fuzzy instance has the specified grouping_key + """ + @spec has_grouping_key?(t, grouping_key()) :: boolean + def has_grouping_key?(%__MODULE__{} = fuzzy, grouping_key) do + Map.has_key?(fuzzy.grouping_key_to_values, grouping_key) + end + + @doc """ + Returns true if the fuzzy instance has the specified subject. + + If the subject is a string, the conversion function passed into the + constructor will be applied to the `subject` parameter. + """ + @spec has_subject?(t, extracted_subject() | subject()) :: boolean + def has_subject?(%__MODULE__{} = fuzzy, subject) when is_binary(subject) do + Map.has_key?(fuzzy.subject_to_values, subject) + end + + def has_subject?(%__MODULE__{} = fuzzy, subject) do + has_subject?(fuzzy, fuzzy.subject_converter.(subject)) + end + + @spec delete_grouping_key(t, grouping_key()) :: t + def delete_grouping_key(%__MODULE__{} = fuzzy, grouping_key) do + values = Map.get(fuzzy.grouping_key_to_values, grouping_key, []) + fuzzy = drop_values(fuzzy, values) + + %__MODULE__{ + fuzzy + | grouping_key_to_values: Map.delete(fuzzy.grouping_key_to_values, grouping_key) + } + end + + @spec drop_values(t, [value()]) :: t + def drop_values(%__MODULE__{} = fuzzy, []) do + # a little optimization; drop_values is pretty expensive, and it's used in + # delete_grouping_key. If there is nothing to delete, we should just return the fuzzy + # unmodified. + fuzzy + end + + @doc """ + Removes all the given values from the data structure. + + If dropping the values results in a subject or grouping key having no entries in the data structure, + the subject or grouping key is also removed. + """ + def drop_values(%__MODULE__{} = fuzzy, values) do + values_mapset = MapSet.new(values) + + reject_values = fn {subject, values} -> + {subject, Enum.reject(values, &MapSet.member?(values_mapset, &1))} + end + + empty_values? = fn + {_, []} -> true + {_, _} -> false + end + + subject_to_values = + fuzzy.subject_to_values + |> Stream.map(reject_values) + |> Stream.reject(empty_values?) + |> Map.new() + + all_subjects = + subject_to_values + |> Map.keys() + |> MapSet.new() + + grouping_key_to_values = + fuzzy.grouping_key_to_values + |> Stream.map(reject_values) + |> Stream.reject(empty_values?) + |> Map.new() + + preprocessed_subjects = + fuzzy.preprocessed_subjects + |> Stream.filter(fn {subject, _} -> + MapSet.member?(all_subjects, subject) + end) + |> Map.new() + + %__MODULE__{ + fuzzy + | subject_to_values: subject_to_values, + grouping_key_to_values: grouping_key_to_values, + preprocessed_subjects: preprocessed_subjects + } + end + + defp score(%__MODULE__{} = fuzzy, subject, pattern) do + with {:ok, preprocessed} <- Map.fetch(fuzzy.preprocessed_subjects, subject), + {true, score} <- Scorer.score(preprocessed, pattern) do + {:ok, score} + else + _ -> + :error + end + end + + defp stringify(mapped(type: {:function, _}, subject: subject)) do + subject + |> String.split(".") + |> List.last() + |> String.split("/") + |> List.first() + end + + defp stringify(mapped(type: :module, subject: module_name)) do + Forge.Formats.module(module_name) + end + + defp stringify(mapped(subject: string)) when is_binary(string) do + string + end + + defp stringify(mapped(subject: thing)) do + inspect(thing) + end + + defp stringify(thing) when is_binary(thing) do + thing + end + + defp stringify(atom) when is_atom(atom) do + cond do + function_exported?(atom, :__info__, 1) -> + Forge.Formats.module(atom) + + function_exported?(atom, :module_info, 0) -> + Forge.Formats.module(atom) + + true -> + inspect(atom) + end + end + + defp stringify(thing) do + inspect(thing) + end + + defp default_mapper do + fn %Entry{} = entry -> + mapped( + application: entry.application, + grouping_key: entry.path, + subject: entry.subject, + subtype: entry.subtype, + type: entry.type, + value: entry.id + ) + end + end + + defp build_filter_fn do + deps_directories = + if Mix.Project.get() do + deps_roots() + else + {:ok, deps_roots} = + Forge.Mix.in_project(fn _ -> + deps_roots() + end) + + deps_roots + end + + fn + mapped(subtype: :definition, grouping_key: path) -> + # if we don't have an app name, just make sure we're not + # in what looks like a deps directory + not Enum.any?(deps_directories, &String.starts_with?(path, &1)) + + _ -> + false + end + end + + defp deps_roots do + deps_roots(Forge.get_project()) + end + + defp deps_roots(%Project{mix_project?: true} = project) do + # Note: This function assumes that the deps directories for all + # found projects is `deps`. Projects may override this directory + # and lexical won't understand this. This was done because loading + # each sub-project is expensive and changes our global directory. + + [Project.root_path(project), "**", "mix.exs"] + |> Path.join() + |> Path.wildcard() + |> Enum.map(fn relative_mix_path -> + relative_mix_path + |> Path.absname() + |> Path.dirname() + |> Path.join("deps") + end) + |> Enum.filter(&File.exists?/1) + end + + defp deps_roots(_) do + [] + end +end diff --git a/forge/lib/forge/search/fuzzy/scorer.ex b/forge/lib/forge/search/fuzzy/scorer.ex new file mode 100644 index 00000000..e23e95a8 --- /dev/null +++ b/forge/lib/forge/search/fuzzy/scorer.ex @@ -0,0 +1,310 @@ +defmodule Forge.Search.Fuzzy.Scorer do + @moduledoc """ + Scores a match based on heuristics. + + The goal of this module is to have a quick to build and fast to query fuzzy matching system. + + Matches match a subject based on a pattern given by the user. A string is considered to match + if the subject contains all of the pattern's characters, in any order. However, patterns + can be boosted based on heuristics. + + The heuristics boost: + 1. Larger patterns + 2. Patterns that match more consecutive characters + 3. Patterns that match the beginning of the subject + 4. Patterns that match the case of the subject + 5. Patterns that match the tail of a subject starting at the last period + + Based loosely on https://medium.com/@Srekel/implementing-a-fuzzy-search-algorithm-for-the-debuginator-cacc349e6c55 + """ + defstruct match?: false, + index: 0, + matched_character_positions: [] + + import Record + + defrecord :subject, graphemes: nil, normalized: nil, period_positions: [-1] + + @typedoc "A match score. Higher numbers mean a more relevant match." + @type score :: integer + @type score_result :: {match? :: boolean(), score} + @type subject :: term() + @type pattern :: String.t() + @type preprocessed :: + record(:subject, graphemes: tuple(), normalized: String.t()) + @non_match_score -5000 + + @doc """ + Pre-processes a subject into separate parts that will be helpful during the search phase. + Pre-processing allows us to do the work of extracting important metadata per-subject + rather than on every request. + """ + @spec preprocess(subject()) :: preprocessed() + def preprocess(subject) when is_binary(subject) do + graphemes = + subject + |> String.graphemes() + |> List.to_tuple() + + normalized = normalize(subject) + + subject( + graphemes: graphemes, + normalized: normalized, + period_positions: period_positions(normalized) + ) + end + + def preprocess(subject) do + subject + |> inspect() + |> preprocess() + end + + @doc """ + Scores the pattern based on the subject + + Returns a two-element tuple, where the first element is a boolean representing if the + pattern matches the subject. The second element is the score of the match. Higher + scores mean a better match. Scores can be negative. + """ + @spec score(subject(), pattern()) :: score_result() + def score(subject, pattern) when is_binary(subject) do + subject + |> preprocess() + |> score(pattern) + end + + def score(subject(normalized: normalized) = subject, pattern) do + normalized_pattern = normalize(pattern) + + case collect_scores(normalized, normalized_pattern) do + [] -> + {false, @non_match_score} + + elems -> + max_score = + elems + |> Enum.map(&calculate_score(&1, subject, pattern)) + |> Enum.max() + + {true, max_score} + end + end + + defp collect_scores(normalized, normalized_pattern, starting_index \\ 0, acc \\ []) + + defp collect_scores(normalized_subject, normalized_pattern, starting_index, scores) do + # we collect scores because it's possible that a better match occurs later + # in the subject, and if we start peeling off characters greedily, we'll miss + # it. This is more expensive, but it's still pretty quick. + + initial_score = %__MODULE__{index: starting_index} + + case do_score(normalized_subject, normalized_pattern, initial_score) do + %__MODULE__{match?: true, matched_character_positions: [pos | _]} = score -> + slice_start = pos + 1 + next_index = starting_index + slice_start + subject_substring = String.slice(normalized_subject, slice_start..-1//1) + scores = [score | scores] + collect_scores(subject_substring, normalized_pattern, next_index, scores) + + _ -> + scores + end + end + + # out of pattern, we have a match. + defp do_score(_, <<>>, %__MODULE__{} = score) do + %__MODULE__{ + score + | match?: true, + matched_character_positions: Enum.reverse(score.matched_character_positions) + } + end + + # we're out of subject, but we still have pattern, no match + defp do_score(<<>>, _, %__MODULE__{} = score) do + %__MODULE__{ + score + | matched_character_positions: Enum.reverse(score.matched_character_positions) + } + end + + defp do_score( + <>, + <>, + %__MODULE__{} = score + ) do + score = + score + |> add_to_list(:matched_character_positions, score.index) + |> increment(:index) + + do_score(subject_rest, pattern_rest, score) + end + + defp do_score(<<_unmatched::utf8, subject_rest::binary>>, pattern, %__MODULE__{} = score) do + score = increment(score, :index) + + do_score(subject_rest, pattern, score) + end + + defp increment(%__MODULE__{} = score, field_name) do + Map.update!(score, field_name, &(&1 + 1)) + end + + defp add_to_list(%__MODULE__{} = score, field_name, value) do + Map.update(score, field_name, [value], &[value | &1]) + end + + defp calculate_score(%__MODULE__{match?: false}, _, _) do + @non_match_score + end + + defp calculate_score(%__MODULE__{} = score, subject(graphemes: graphemes) = subject, pattern) do + pattern_length = String.length(pattern) + + {consecutive_count, consecutive_bonus} = + consecutive_match_boost(score.matched_character_positions) + + match_amount_boost = consecutive_count * pattern_length + + match_boost = tail_match_boost(score, subject, pattern_length) + + camel_case_boost = camel_case_boost(score.matched_character_positions, subject) + + mismatched_penalty = mismatched_penalty(score.matched_character_positions) + + incompleteness_penalty = tuple_size(graphemes) - length(score.matched_character_positions) + + consecutive_bonus + match_boost + camel_case_boost + + match_amount_boost - mismatched_penalty - incompleteness_penalty + end + + defp normalize(string) do + String.downcase(string) + end + + @tail_match_boost 55 + + defp tail_match_boost( + %__MODULE__{} = score, + subject(graphemes: graphemes, period_positions: period_positions), + pattern_length + ) do + [first_match_position | _] = score.matched_character_positions + + match_end = first_match_position + pattern_length + subject_length = tuple_size(graphemes) + + if MapSet.member?(period_positions, first_match_position - 1) and match_end == subject_length do + # reward a complete match at the end of the last period. This is likely a module + # and the pattern matches the most local parts + @tail_match_boost + else + 0 + end + end + + @consecutive_character_bonus 15 + + def consecutive_match_boost(matched_positions) do + # This function checks for consecutive matched characters, and + # makes matches with more consecutive matched characters worth more. + # This means if I type En, it will match Enum more than it will match + # Something + + max_streak = + matched_positions + |> Enum.reduce([[]], fn + current, [[last | streak] | rest] when last == current - 1 -> + [[current, last | streak] | rest] + + current, acc -> + [[current] | acc] + end) + |> Enum.max_by(&length/1) + + streak_length = length(max_streak) + {streak_length, @consecutive_character_bonus * streak_length} + end + + @mismatched_chracter_penalty 5 + + def mismatched_penalty(matched_positions) do + {penalty, _} = + matched_positions + |> Enum.reduce({0, -1}, fn + matched_position, {0, _} -> + # only start counting the penalty after the first match, + # otherwise we will inadvertently penalize matches deeper in the string + {0, matched_position} + + matched_position, {penalty, last_match} -> + distance = matched_position - last_match + + {penalty + distance * @mismatched_chracter_penalty, matched_position} + end) + + penalty + end + + @camel_case_boost 5 + defp camel_case_boost(matched_positions, subject(graphemes: graphemes)) do + graphemes + |> Tuple.to_list() + |> camel_positions() + |> Enum.reduce(0, fn position, score -> + if position in matched_positions do + score + @camel_case_boost + else + score + end + end) + end + + defp camel_positions(graphemes) do + camel_positions(graphemes, {nil, :lower}, 0, []) + end + + defp camel_positions([], _, _, positions) do + Enum.reverse(positions) + end + + defp camel_positions([grapheme | rest], {_last_char, :lower}, position, positions) do + case case_of(grapheme) do + :lower -> + camel_positions(rest, {grapheme, :lower}, position + 1, positions) + + :upper -> + camel_positions(rest, {grapheme, :upper}, position + 1, [position | positions]) + end + end + + defp camel_positions([grapheme | rest], {_last_char, :upper}, position, positions) do + camel_positions(rest, {grapheme, case_of(grapheme)}, position + 1, positions) + end + + defp case_of(grapheme) do + if String.downcase(grapheme) == grapheme do + :lower + else + :upper + end + end + + defp period_positions(string) do + period_positions(string, 0, [-1]) + end + + defp period_positions(<<>>, _, positions), do: MapSet.new(positions) + + defp period_positions(<<".", rest::binary>>, position, positions) do + period_positions(rest, position + 1, [position | positions]) + end + + defp period_positions(<<_::utf8, rest::binary>>, position, positions) do + period_positions(rest, position + 1, positions) + end +end diff --git a/forge/lib/forge/search/indexer.ex b/forge/lib/forge/search/indexer.ex new file mode 100644 index 00000000..a76fde1f --- /dev/null +++ b/forge/lib/forge/search/indexer.ex @@ -0,0 +1,211 @@ +defmodule Forge.Search.Indexer do + alias Forge.Identifier + alias Forge.ProcessCache + alias Forge.Project + + alias Engine.Progress + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry + + require ProcessCache + + @indexable_extensions "*.{ex,exs}" + + def create_index(%Project{} = project) do + ProcessCache.with_cleanup do + deps_dir = deps_dir() + + entries = + project + |> indexable_files() + |> async_chunks(&index_path(&1, deps_dir)) + + {:ok, entries} + end + end + + def update_index(%Project{} = project, backend) do + ProcessCache.with_cleanup do + do_update_index(project, backend) + end + end + + defp do_update_index(%Project{} = project, backend) do + path_to_ids = + backend.reduce(%{}, fn + %Entry{path: path} = entry, path_to_ids when is_integer(entry.id) -> + Map.update(path_to_ids, path, entry.id, &max(&1, entry.id)) + + _entry, path_to_ids -> + path_to_ids + end) + + project_files = + project + |> indexable_files() + |> MapSet.new() + + previously_indexed_paths = MapSet.new(path_to_ids, fn {path, _} -> path end) + + new_paths = MapSet.difference(project_files, previously_indexed_paths) + + {paths_to_examine, paths_to_delete} = + Enum.split_with(path_to_ids, fn {path, _} -> File.regular?(path) end) + + changed_paths = + for {path, id} <- paths_to_examine, + newer_than?(path, id) do + path + end + + paths_to_delete = Enum.map(paths_to_delete, &elem(&1, 0)) + + paths_to_reindex = changed_paths ++ Enum.to_list(new_paths) + + entries = async_chunks(paths_to_reindex, &index_path(&1, deps_dir())) + + {:ok, entries, paths_to_delete} + end + + defp index_path(path, deps_dir) do + with {:ok, contents} <- File.read(path), + {:ok, entries} <- Indexer.Source.index(path, contents) do + Enum.filter(entries, fn entry -> + if contained_in?(path, deps_dir) do + entry.subtype == :definition + else + true + end + end) + else + _ -> + [] + end + end + + # 128 K blocks indexed lexical in 5.3 seconds + @bytes_per_block 1024 * 128 + defp async_chunks(file_paths, processor, timeout \\ :infinity) do + # this function tries to even out the amount of data processed by + # async stream by making each chunk emitted by the initial stream to + # be roughly equivalent + + # Shuffling the results helps speed in some projects, as larger files tend to clump + # together, like when there are auto-generated elixir modules. + paths_to_sizes = + file_paths + |> path_to_sizes() + |> Enum.shuffle() + + path_to_size_map = Map.new(paths_to_sizes) + + total_bytes = paths_to_sizes |> Enum.map(&elem(&1, 1)) |> Enum.sum() + + {on_update_progess, on_complete} = Progress.begin_percent("Indexing source code", total_bytes) + + initial_state = {0, []} + + chunk_fn = fn {path, file_size}, {block_size, paths} -> + new_block_size = file_size + block_size + new_paths = [path | paths] + + if new_block_size >= @bytes_per_block do + {:cont, new_paths, initial_state} + else + {:cont, {new_block_size, new_paths}} + end + end + + after_fn = fn + {_, []} -> + {:cont, []} + + {_, paths} -> + {:cont, paths, []} + end + + paths_to_sizes + |> Stream.chunk_while(initial_state, chunk_fn, after_fn) + |> Task.async_stream( + fn chunk -> + block_bytes = chunk |> Enum.map(&Map.get(path_to_size_map, &1)) |> Enum.sum() + result = Enum.map(chunk, processor) + on_update_progess.(block_bytes, "Indexing") + result + end, + timeout: timeout + ) + |> Stream.flat_map(fn + {:ok, entry_chunks} -> entry_chunks + _ -> [] + end) + # The next bit is the only way i could figure out how to + # call complete once the stream was realized + |> Stream.transform( + fn -> nil end, + fn chunk_items, acc -> + # By the chunk items list directly, each transformation + # will flatten the resulting steam + {chunk_items, acc} + end, + fn _acc -> + on_complete.() + end + ) + end + + defp path_to_sizes(paths) do + Enum.reduce(paths, [], fn file_path, acc -> + case File.stat(file_path) do + {:ok, %File.Stat{} = stat} -> + [{file_path, stat.size} | acc] + + _ -> + acc + end + end) + end + + defp newer_than?(path, entry_id) do + case stat(path) do + {:ok, %File.Stat{} = stat} -> + stat.mtime > Identifier.to_erl(entry_id) + + _ -> + false + end + end + + def indexable_files(%Project{} = project) do + root_dir = Project.root_path(project) + build_dir = build_dir() + + [root_dir, "**", @indexable_extensions] + |> Path.join() + |> Path.wildcard() + |> Enum.reject(&contained_in?(&1, build_dir)) + end + + # stat(path) is here for testing so it can be mocked + defp stat(path) do + File.stat(path) + end + + defp contained_in?(file_path, possible_parent) do + String.starts_with?(file_path, possible_parent) + end + + defp deps_dir do + case Forge.Mix.in_project(&Mix.Project.deps_path/0) do + {:ok, path} -> path + _ -> Mix.Project.deps_path() + end + end + + defp build_dir do + case Forge.Mix.in_project(&Mix.Project.build_path/0) do + {:ok, path} -> path + _ -> Mix.Project.build_path() + end + end +end diff --git a/forge/lib/forge/search/indexer/entry.ex b/forge/lib/forge/search/indexer/entry.ex new file mode 100644 index 00000000..2e4ff895 --- /dev/null +++ b/forge/lib/forge/search/indexer/entry.ex @@ -0,0 +1,155 @@ +defmodule Forge.Search.Indexer.Entry do + @type function_type :: :public | :private | :delegated | :usage + @type protocol_type :: :implementation | :definition + + @type entry_type :: + :ex_unit_describe + | :ex_unit_test + | :module + | :module_attribute + | :struct + | :variable + | {:protocol, protocol_type()} + | {:function, function_type()} + + @type subject :: String.t() + @type entry_subtype :: :reference | :definition + @type version :: String.t() + @type entry_id :: pos_integer() | nil + @type block_id :: pos_integer() | :root + @type subject_query :: subject() | :_ + @type entry_type_query :: entry_type() | :_ + @type entry_subtype_query :: entry_subtype() | :_ + @type constraint :: {:type, entry_type_query()} | {:subtype, entry_subtype_query()} + @type constraints :: [constraint()] + + defstruct [ + :application, + :id, + :block_id, + :block_range, + :path, + :range, + :subject, + :subtype, + :type, + :metadata + ] + + @type t :: %__MODULE__{ + application: module(), + subject: subject(), + block_id: block_id(), + block_range: Forge.Document.Range.t() | nil, + path: Path.t(), + range: Forge.Document.Range.t(), + subtype: entry_subtype(), + type: entry_type(), + metadata: nil | map() + } + @type datetime_format :: :erl | :unix | :datetime + @type date_type :: :calendar.datetime() | integer() | DateTime.t() + + alias Forge.Identifier + alias Forge.Search.Indexer.Source.Block + alias Forge.StructAccess + + use StructAccess + + defguard is_structure(entry) when entry.type == :metadata and entry.subtype == :block_structure + defguard is_block(entry) when entry.id == entry.block_id + + @doc """ + Creates a new entry by copying the passed-in entry. + + The returned entry will have the same fields set as the one passed in, + but a different id. + You can also pass in a keyword list of overrides, which will overwrit values in + the returned struct. + """ + def copy(%__MODULE__{} = orig, overrides \\ []) when is_list(overrides) do + %__MODULE__{orig | id: Identifier.next_global!()} + |> struct(overrides) + end + + def block_structure(path, structure) do + %__MODULE__{ + path: path, + subject: structure, + type: :metadata, + subtype: :block_structure + } + end + + def reference(path, %Block{} = block, subject, type, range, application) do + new(path, Identifier.next_global!(), block.id, subject, type, :reference, range, application) + end + + def definition(path, %Block{} = block, subject, type, range, application) do + new(path, Identifier.next_global!(), block.id, subject, type, :definition, range, application) + end + + def block_definition( + path, + %Block{} = block, + subject, + type, + block_range, + detail_range, + application + ) do + definition = + definition( + path, + block.id, + block.parent_id, + subject, + type, + detail_range, + application + ) + + %__MODULE__{definition | block_range: block_range} + end + + defp definition(path, id, block_id, subject, type, range, application) do + new(path, id, block_id, subject, type, :definition, range, application) + end + + defp new(path, id, block_id, subject, type, subtype, range, application) do + %__MODULE__{ + application: application, + block_id: block_id, + id: id, + path: path, + range: range, + subject: subject, + subtype: subtype, + type: type + } + end + + def block?(%__MODULE__{} = entry) do + is_block(entry) + end + + @spec updated_at(t()) :: date_type() + @spec updated_at(t(), datetime_format) :: date_type() + def updated_at(entry, format \\ :erl) + + def updated_at(%__MODULE__{id: id} = entry, format) when is_integer(id) do + case format do + :erl -> Identifier.to_erl(entry.id) + :unix -> Identifier.to_unix(id) + :datetime -> Identifier.to_datetime(id) + end + end + + def updated_at(%__MODULE__{}, _format) do + nil + end + + def put_metadata(%__MODULE__{} = entry, metadata) do + %__MODULE__{entry | metadata: metadata} + end +end diff --git a/forge/lib/forge/search/indexer/extractors/ecto_schema.ex b/forge/lib/forge/search/indexer/extractors/ecto_schema.ex new file mode 100644 index 00000000..1e14ddb1 --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/ecto_schema.ex @@ -0,0 +1,112 @@ +defmodule Forge.Search.Indexer.Extractors.EctoSchema do + alias Forge.Ast + alias Forge.Document.Position + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer + + def extract( + {:schema, meta, [{:__block__, _, [_source]} | _]} = schema_block, + %Reducer{} = reducer + ) do + case extract_schema_entry(schema_block, meta, reducer) do + {:ok, _} = success -> success + :error -> :ignored + end + end + + def extract( + {:embedded_schema, meta, _} = schema_block, + %Reducer{} = reducer + ) do + case extract_schema_entry(schema_block, meta, reducer) do + {:ok, _} = success -> success + :error -> :ignored + end + end + + @embeds [:embeds_one, :embeds_many] + def extract( + {embed_type, _, [_name, {:__aliases__, _, schema_segments} = schema_module | rest]} = + embed, + %Reducer{} = reducer + ) + when embed_type in @embeds do + document = reducer.analysis.document + position = Reducer.position(reducer) + + with true <- block_form?(rest), + {:ok, module} <- Analyzer.current_module(reducer.analysis, position), + {:ok, expanded} <- Analyzer.expand_alias(schema_segments, reducer.analysis, position), + {:ok, block_range} <- Ast.Range.fetch(embed, document), + {:ok, detail_range} <- Ast.Range.fetch(schema_module, document) do + struct_module = Module.concat(module, expanded) + + definition = + Entry.block_definition( + document.path, + Reducer.current_block(reducer), + struct_module, + :struct, + block_range, + detail_range, + Application.get_application(struct_module) + ) + + {:ok, definition} + else + _ -> + :ignored + end + end + + def extract(_ast, _reducer) do + :ignored + end + + defp extract_schema_entry(schema_block, meta, %Reducer{} = reducer) do + document = reducer.analysis.document + position = Reducer.position(reducer) + + with true <- defines_schema?(reducer, position), + {:ok, current_module} <- Analyzer.current_module(reducer.analysis, position), + {do_line, do_column} <- Metadata.position(meta, :do), + {:ok, range} <- Ast.Range.fetch(schema_block, document) do + detail_range = put_in(range.end, Position.new(document, do_line, do_column + 2)) + + definition_entry = + Entry.block_definition( + document.path, + Reducer.current_block(reducer), + current_module, + :struct, + range, + detail_range, + Application.get_application(current_module) + ) + + {:ok, definition_entry} + else + _ -> + :error + end + end + + defp defines_schema?(%Reducer{} = reducer, %Position{} = position) do + Ecto.Schema in Analyzer.uses_at(reducer.analysis, position) + end + + defp block_form?(ast) do + {_, result} = + Macro.prewalk(ast, false, fn + {:__block__, _, [:do]}, false -> + {nil, true} + + ast, acc -> + {ast, acc} + end) + + result + end +end diff --git a/forge/lib/forge/search/indexer/extractors/ex_unit.ex b/forge/lib/forge/search/indexer/extractors/ex_unit.ex new file mode 100644 index 00000000..855ac6d7 --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/ex_unit.ex @@ -0,0 +1,128 @@ +defmodule Forge.Search.Indexer.Extractors.ExUnit do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Formats + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer + + require Logger + + # setup block i.e. setup do... or setup arg do... + def extract({setup_fn, _, args} = setup, %Reducer{} = reducer) + when setup_fn in [:setup, :setup_all] and length(args) > 0 do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + subject = Formats.mfa(module, setup_fn, arity) + setup_type = :"ex_unit_#{setup_fn}" + + entry = + case Metadata.location(setup) do + {:block, _, _, _} -> + block_entry(reducer, setup, setup_type, subject) + + {:expression, _} -> + expression_entry(reducer, setup, setup_type, subject) + end + + {:ok, entry} + end + + # Test block test "test name" do ... or test "test name", arg do + def extract({:test, _, [{_, _, [test_name]} | _] = args} = test, %Reducer{} = reducer) + when is_binary(test_name) do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + module_name = Formats.module(module) + subject = "#{module_name}.[\"#{test_name}\"]/#{arity}" + + entry = + case Metadata.location(test) do + {:block, _, _, _} -> + # a test with a body + block_entry(reducer, test, :ex_unit_test, subject) + + {:expression, _} -> + # a pending test + expression_entry(reducer, test, :ex_unit_test, subject) + end + + {:ok, entry} + end + + # describe blocks + def extract({:describe, _, [{_, _, [describe_name]} | _] = args} = test, %Reducer{} = reducer) do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + module_name = Formats.module(module) + subject = "#{module_name}[\"#{describe_name}\"]/#{arity}" + + entry = block_entry(reducer, test, :ex_unit_describe, subject) + + {:ok, entry} + end + + def extract(_ign, _) do + :ignored + end + + defp expression_entry(%Reducer{} = reducer, ast, type, subject) do + path = reducer.analysis.document.path + block = Reducer.current_block(reducer) + + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + app = Application.get_application(module) + detail_range = detail_range(reducer.analysis, ast) + + Entry.definition(path, block, subject, type, detail_range, app) + end + + defp block_entry(%Reducer{} = reducer, ast, type, subject) do + path = reducer.analysis.document.path + block = Reducer.current_block(reducer) + + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + app = Application.get_application(module) + detail_range = detail_range(reducer.analysis, ast) + block_range = block_range(reducer.analysis, ast) + Entry.block_definition(path, block, subject, type, block_range, detail_range, app) + end + + defp block_range(%Analysis{} = analysis, ast) do + case Ast.Range.fetch(ast, analysis.document) do + {:ok, range} -> range + _ -> nil + end + end + + defp detail_range(%Analysis{} = analysis, ast) do + case Metadata.location(ast) do + {:block, {start_line, start_column}, {do_line, do_column}, _} -> + Range.new( + Position.new(analysis.document, start_line, start_column), + Position.new(analysis.document, do_line, do_column + 2) + ) + + {:expression, {start_line, start_column}} -> + %{end: [line: end_line, column: end_column]} = Sourceror.get_range(ast) + + Range.new( + Position.new(analysis.document, start_line, start_column), + Position.new(analysis.document, end_line, end_column) + ) + end + end + + defp arity_for([{:__block__, _meta, labels}]) do + length(labels) + end + + defp arity_for(args) when is_list(args) do + length(args) + end + + defp arity_for(_), do: 0 +end diff --git a/forge/lib/forge/search/indexer/extractors/function_definition.ex b/forge/lib/forge/search/indexer/extractors/function_definition.ex new file mode 100644 index 00000000..02326c89 --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/function_definition.ex @@ -0,0 +1,110 @@ +defmodule Forge.Search.Indexer.Extractors.FunctionDefinition do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer + alias Forge.Search.Subject + + @function_definitions [:def, :defp] + + def extract({definition, _, [{fn_name, _, args} = def_ast, body]} = ast, %Reducer{} = reducer) + when is_atom(fn_name) and definition in @function_definitions do + with {:ok, detail_range} <- Ast.Range.fetch(def_ast, reducer.analysis.document), + {:ok, module} <- Analyzer.current_module(reducer.analysis, detail_range.start), + {fun_name, arity} when is_atom(fun_name) <- fun_name_and_arity(def_ast) do + entry = + Entry.block_definition( + reducer.analysis.document.path, + Reducer.current_block(reducer), + Subject.mfa(module, fun_name, arity), + type(definition), + block_range(reducer.analysis, ast), + detail_range, + Application.get_application(module) + ) + + {:ok, entry, [args, body]} + else + _ -> + :ignored + end + end + + def extract({:defdelegate, _, [call, _]} = node, %Reducer{} = reducer) do + document = reducer.analysis.document + + with {:ok, detail_range} <- Ast.Range.fetch(call, document), + {:ok, module} <- Analyzer.current_module(reducer.analysis, detail_range.start), + {:ok, {delegated_module, delegated_name, _delegated_arity}} <- + fetch_delegated_mfa(node, reducer.analysis, detail_range.start) do + {delegate_name, args} = Macro.decompose_call(call) + arity = length(args) + metadata = %{original_mfa: Subject.mfa(delegated_module, delegated_name, arity)} + + entry = + Entry.definition( + document.path, + Reducer.current_block(reducer), + Subject.mfa(module, delegate_name, arity), + {:function, :delegate}, + detail_range, + Application.get_application(module) + ) + + {:ok, Entry.put_metadata(entry, metadata)} + else + _ -> + :ignored + end + end + + def extract(_ast, _reducer) do + :ignored + end + + def fetch_delegated_mfa({:defdelegate, _, [call | keywords]}, analysis, position) do + {_, keyword_args} = + Macro.prewalk(keywords, [], fn + {{:__block__, _, [:to]}, {:__aliases__, _, delegated_module}} = ast, acc -> + {ast, Keyword.put(acc, :to, delegated_module)} + + {{:__block__, _, [:as]}, {:__block__, _, [remote_fun_name]}} = ast, acc -> + {ast, Keyword.put(acc, :as, remote_fun_name)} + + ast, acc -> + {ast, acc} + end) + + with {function_name, args} <- Macro.decompose_call(call), + {:ok, module} <- Analyzer.expand_alias(keyword_args[:to], analysis, position) do + function_name = Keyword.get(keyword_args, :as, function_name) + {:ok, {module, function_name, length(args)}} + else + _ -> + :error + end + end + + defp type(:def), do: {:function, :public} + defp type(:defp), do: {:function, :private} + + defp fun_name_and_arity({:when, _, [{fun_name, _, fun_args} | _]}) do + # a function with guards + {fun_name, arity(fun_args)} + end + + defp fun_name_and_arity({fun_name, _, fun_args}) do + {fun_name, arity(fun_args)} + end + + defp arity(nil), do: 0 + defp arity(args) when is_list(args), do: length(args) + + defp block_range(%Analysis{} = analysis, def_ast) do + case Ast.Range.fetch(def_ast, analysis.document) do + {:ok, range} -> range + _ -> nil + end + end +end diff --git a/forge/lib/forge/search/indexer/extractors/function_reference.ex b/forge/lib/forge/search/indexer/extractors/function_reference.ex new file mode 100644 index 00000000..57eb917a --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/function_reference.ex @@ -0,0 +1,276 @@ +defmodule Forge.Search.Indexer.Extractors.FunctionReference do + alias Forge.Ast + alias Forge.Document.Position + alias Forge.Document.Range + + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors.FunctionDefinition + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer + alias Forge.Search.Subject + + require Logger + + @excluded_functions_key {__MODULE__, :excluded_functions} + # Dynamic calls using apply apply(Module, :function, [1, 2]) + def extract( + {:apply, apply_meta, + [ + {:__aliases__, _, module}, + {:__block__, _, [function_name]}, + {:__block__, _, + [ + arg_list + ]} + ]}, + %Reducer{} = reducer + ) + when is_list(arg_list) and is_atom(function_name) do + entry = entry(reducer, apply_meta, apply_meta, module, function_name, arg_list) + {:ok, entry, nil} + end + + # Dynamic call via Kernel.apply Kernel.apply(Module, :function, [1, 2]) + def extract( + {{:., _, [{:__aliases__, start_metadata, [:Kernel]}, :apply]}, apply_meta, + [ + {:__aliases__, _, module}, + {:__block__, _, [function_name]}, + {:__block__, _, [arg_list]} + ]}, + %Reducer{} = reducer + ) + when is_list(arg_list) and is_atom(function_name) do + entry = entry(reducer, start_metadata, apply_meta, module, function_name, arg_list) + {:ok, entry, nil} + end + + # remote function OtherModule.foo(:arg), OtherModule.foo() or OtherModule.foo + def extract( + {{:., _, [{:__aliases__, start_metadata, module}, fn_name]}, end_metadata, args}, + %Reducer{} = reducer + ) + when is_atom(fn_name) do + entry = entry(reducer, start_metadata, end_metadata, module, fn_name, args) + + {:ok, entry} + end + + # local function capture &downcase/1 + def extract( + {:/, _, [{fn_name, end_metadata, nil}, {:__block__, arity_meta, [arity]}]}, + %Reducer{} = reducer + ) do + position = Reducer.position(reducer) + + {module, _, _} = + Forge.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + + entry = entry(reducer, end_metadata, arity_meta, module, fn_name, arity) + {:ok, entry, nil} + end + + # Function capture with arity: &OtherModule.foo/3 + def extract( + {:&, _, + [ + {:/, _, + [ + {{:., _, [{:__aliases__, start_metadata, module}, function_name]}, _, []}, + {:__block__, end_metadata, [arity]} + ]} + ]}, + %Reducer{} = reducer + ) do + entry = entry(reducer, start_metadata, end_metadata, module, function_name, arity) + + # we return nil here to stop analysis from progressing down the syntax tree, + # because if it did, the function head that deals with normal calls will pick + # up the rest of the call and return a reference to MyModule.function/0, which + # is incorrect + {:ok, entry, nil} + end + + def extract({:|>, pipe_meta, [pipe_start, {fn_name, meta, args}]}, %Reducer{}) do + # we're in a pipeline. Skip this node by returning nil, but add a marker to the metadata + # that will be picked up by call_arity. + updated_meta = Keyword.put(meta, :pipeline?, true) + new_pipe = {:|>, pipe_meta, [pipe_start, {fn_name, updated_meta, args}]} + + {:ok, nil, new_pipe} + end + + def extract({:defdelegate, _, _} = ast, %Reducer{} = reducer) do + analysis = reducer.analysis + position = Reducer.position(reducer) + + case FunctionDefinition.fetch_delegated_mfa(ast, analysis, position) do + {:ok, {module, function_name, arity}} -> + entry = + Entry.reference( + analysis.document.path, + Reducer.current_block(reducer), + Forge.Formats.mfa(module, function_name, arity), + {:function, :usage}, + Ast.Range.get(ast, analysis.document), + Application.get_application(module) + ) + + {:ok, entry, []} + + _ -> + :ignored + end + end + + # local function call foo() foo(arg) + def extract({fn_name, meta, args}, %Reducer{} = reducer) + when is_atom(fn_name) and is_list(args) do + if fn_name in excluded_functions() do + :ignored + else + arity = call_arity(args, meta) + position = Reducer.position(reducer) + + {module, _, _} = + Forge.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + + entry = entry(reducer, meta, meta, [module], fn_name, args) + + {:ok, entry} + end + end + + def extract(_ast, _reducer) do + :ignored + end + + defp entry( + %Reducer{} = reducer, + start_metadata, + end_metadata, + module, + function_name, + args_arity + ) do + arity = call_arity(args_arity, end_metadata) + block = Reducer.current_block(reducer) + + range = + get_reference_range(reducer.analysis.document, start_metadata, end_metadata, function_name) + + case Forge.Analyzer.expand_alias(module, reducer.analysis, range.start) do + {:ok, module} -> + mfa = Subject.mfa(module, function_name, arity) + + Entry.reference( + reducer.analysis.document.path, + block, + mfa, + {:function, :usage}, + range, + Application.get_application(module) + ) + + _ -> + human_location = Reducer.human_location(reducer) + + Logger.warning( + "Could not expand #{inspect(module)} into an alias. Please report this. (at #{human_location})" + ) + + nil + end + end + + defp get_reference_range(document, start_metadata, end_metadata, function_name) do + {start_line, start_column} = start_position(start_metadata) + start_position = Position.new(document, start_line, start_column) + has_parens? = not Keyword.get(end_metadata, :no_parens, false) + + {end_line, end_column} = + case Metadata.position(end_metadata, :closing) do + {line, column} -> + if has_parens? do + {line, column + 1} + else + {line, column} + end + + nil -> + {line, column} = Metadata.position(end_metadata) + + if has_parens? do + {line, column + 1} + else + name_length = function_name |> Atom.to_string() |> String.length() + # without parens, the metadata points to the beginning of the call, so + # we need to add the length of the function name to be sure we have it + # all + {line, column + name_length} + end + end + + end_position = Position.new(document, end_line, end_column) + Range.new(start_position, end_position) + end + + defp start_position(metadata) do + Metadata.position(metadata) + end + + defp call_arity(args, metadata) when is_list(args) do + length(args) + pipeline_arity(metadata) + end + + defp call_arity(arity, metadata) when is_integer(arity) do + arity + pipeline_arity(metadata) + end + + defp call_arity(_, metadata), do: pipeline_arity(metadata) + + defp pipeline_arity(metadata) do + if Keyword.get(metadata, :pipeline?, false) do + 1 + else + 0 + end + end + + defp excluded_functions do + case :persistent_term.get(@excluded_functions_key, :not_found) do + :not_found -> + excluded_functions = build_excluded_functions() + :persistent_term.put(@excluded_functions_key, excluded_functions) + excluded_functions + + excluded_functions -> + excluded_functions + end + end + + defp build_excluded_functions do + excluded_kernel_macros = + for {macro_name, _arity} <- Kernel.__info__(:macros), + string_name = Atom.to_string(macro_name), + String.starts_with?(string_name, "def") do + macro_name + end + + # syntax specific functions to exclude from our matches + excluded_operators = + ~w[<- -> && ** ++ -- .. "..//" ! <> =~ @ |> | || * + - / != !== < <= == === > >=]a + + excluded_keywords = ~w[and if import in not or raise require try use]a + + excluded_special_forms = + :macros + |> Kernel.SpecialForms.__info__() + |> Keyword.keys() + + excluded_kernel_macros + |> Enum.concat(excluded_operators) + |> Enum.concat(excluded_special_forms) + |> Enum.concat(excluded_keywords) + end +end diff --git a/forge/lib/forge/search/indexer/extractors/module.ex b/forge/lib/forge/search/indexer/extractors/module.ex new file mode 100644 index 00000000..a7c40c7d --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/module.ex @@ -0,0 +1,344 @@ +defmodule Forge.Search.Indexer.Extractors.Module do + @moduledoc """ + Extracts module references and definitions from AST + """ + + alias Forge.Ast + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.ProcessCache + + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Block + alias Forge.Search.Indexer.Source.Reducer + alias Forge.Search.Subject + + require Logger + + @definition_mappings %{ + defmodule: :module, + defprotocol: {:protocol, :definition} + } + @module_definitions Map.keys(@definition_mappings) + + # extract a module definition + def extract( + {definition, defmodule_meta, + [{:__aliases__, module_name_meta, module_name}, module_block]} = defmodule_ast, + %Reducer{} = reducer + ) + when definition in @module_definitions do + %Block{} = block = Reducer.current_block(reducer) + + case resolve_alias(reducer, module_name) do + {:ok, aliased_module} -> + module_position = Metadata.position(module_name_meta) + detail_range = to_range(reducer, module_name, module_position) + + entry = + Entry.block_definition( + reducer.analysis.document.path, + block, + Subject.module(aliased_module), + @definition_mappings[definition], + block_range(reducer.analysis.document, defmodule_ast), + detail_range, + Application.get_application(aliased_module) + ) + + module_name_meta = Reducer.skip(module_name_meta) + + elem = + {:defmodule, defmodule_meta, + [{:__aliases__, module_name_meta, module_name}, module_block]} + + {:ok, entry, elem} + + _ -> + :ignored + end + end + + # defimpl MyProtocol, for: MyStruct do ... + def extract( + {:defimpl, _, [{:__aliases__, _, module_name}, [for_block], _impl_body]} = defimpl_ast, + %Reducer{} = reducer + ) do + %Block{} = block = Reducer.current_block(reducer) + + with {:ok, protocol_module} <- resolve_alias(reducer, module_name), + {:ok, for_target} <- resolve_for_block(reducer, for_block) do + detail_range = defimpl_range(reducer, defimpl_ast) + implemented_module = Module.concat(protocol_module, for_target) + + implementation_entry = + Entry.block_definition( + reducer.analysis.document.path, + block, + Subject.module(protocol_module), + {:protocol, :implementation}, + block_range(reducer.analysis.document, defimpl_ast), + detail_range, + Application.get_application(protocol_module) + ) + + module_entry = + Entry.copy(implementation_entry, + subject: Subject.module(implemented_module), + type: :module + ) + + {:ok, [implementation_entry, module_entry]} + else + _ -> + :ignored + end + end + + # This matches an elixir module reference + def extract({:__aliases__, metadata, maybe_module}, %Reducer{} = reducer) + when is_list(maybe_module) do + case module(reducer, maybe_module) do + {:ok, module} -> + start = Metadata.position(metadata) + range = to_range(reducer, maybe_module, start) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry, nil} + + _ -> + :ignored + end + end + + @module_length String.length("__MODULE__") + # This matches __MODULE__ references + def extract({:__MODULE__, metadata, _} = ast, %Reducer{} = reducer) do + line = Sourceror.get_line(ast) + pos = Position.new(reducer.analysis.document, line - 1, 1) + + case Forge.Analyzer.current_module(reducer.analysis, pos) do + {:ok, current_module} -> + {start_line, start_col} = Metadata.position(metadata) + start_pos = Position.new(reducer.analysis.document, start_line, start_col) + + end_pos = + Position.new( + reducer.analysis.document, + start_line, + start_col + @module_length + ) + + range = Range.new(start_pos, end_pos) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(current_module), + :module, + range, + Application.get_application(current_module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + # This matches an erlang module, which is just an atom + def extract({:__block__, metadata, [atom_literal]}, %Reducer{} = reducer) + when is_atom(atom_literal) do + case module(reducer, atom_literal) do + {:ok, module} -> + start = Metadata.position(metadata) + %Block{} = current_block = Reducer.current_block(reducer) + range = to_range(reducer, module, start) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry} + + :error -> + :ignored + end + end + + # Function capture with arity: &OtherModule.foo/3 + def extract( + {:&, _, + [ + {:/, _, + [ + {{:., _, [{:__aliases__, start_metadata, maybe_module}, _function_name]}, _, []}, + _ + ]} + ]}, + %Reducer{} = reducer + ) do + case module(reducer, maybe_module) do + {:ok, module} -> + start = Metadata.position(start_metadata) + range = to_range(reducer, maybe_module, start) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp defimpl_range(%Reducer{} = reducer, {_, protocol_meta, _} = protocol_ast) do + start = Sourceror.get_start_position(protocol_ast) + {finish_line, finish_column} = Metadata.position(protocol_meta, :do) + # add two to include the do + finish_column = finish_column + 2 + document = reducer.analysis.document + + Range.new( + Position.new(document, start[:line], start[:column]), + Position.new(document, finish_line, finish_column) + ) + end + + defp resolve_for_block( + %Reducer{} = reducer, + {{:__block__, _, [:for]}, {:__aliases__, _, for_target}} + ) do + resolve_alias(reducer, for_target) + end + + defp resolve_for_block(_, _), do: :error + + defp resolve_alias(%Reducer{} = reducer, unresolved_alias) do + position = Reducer.position(reducer) + + Forge.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) + end + + defp module(%Reducer{} = reducer, maybe_module) when is_list(maybe_module) do + with true <- Enum.all?(maybe_module, &module_part?/1), + {:ok, resolved} <- resolve_alias(reducer, maybe_module) do + {:ok, resolved} + else + _ -> + human_location = Reducer.human_location(reducer) + + Logger.warning( + "Could not expand module #{inspect(maybe_module)}. Please report this (at #{human_location})" + ) + + :error + end + end + + defp module(%Reducer{}, maybe_erlang_module) when is_atom(maybe_erlang_module) do + if available_module?(maybe_erlang_module) do + {:ok, maybe_erlang_module} + else + :error + end + end + + defp module(_, _), do: :error + + @protocol_module_attribue_names [:protocol, :for] + + @starts_with_capital ~r/[A-Z]+/ + defp module_part?(part) when is_atom(part) do + Regex.match?(@starts_with_capital, Atom.to_string(part)) + end + + defp module_part?({:@, _, [{type, _, _} | _]}) when type in @protocol_module_attribue_names, + do: true + + defp module_part?({:__MODULE__, _, context}) when is_atom(context), do: true + + defp module_part?(_), do: false + + defp available_module?(potential_module) do + MapSet.member?(all_modules(), potential_module) + end + + defp all_modules do + ProcessCache.trans(:all_modules, fn -> + MapSet.new(:code.all_available(), fn {module_charlist, _, _} -> + List.to_atom(module_charlist) + end) + end) + end + + # handles @protocol and @for in defimpl blocks + defp to_range(%Reducer{} = reducer, [{:@, _, [{type, _, _} | _]} = attribute | segments], _) + when type in @protocol_module_attribue_names do + range = Sourceror.get_range(attribute) + + document = reducer.analysis.document + module_length = segments |> Ast.Module.name() |> String.length() + # add one because we're off by the @ sign + end_column = range.end[:column] + module_length + 1 + + Range.new( + Position.new(document, range.start[:line], range.start[:column]), + Position.new(document, range.end[:line], end_column) + ) + end + + defp to_range(%Reducer{} = reducer, module_name, {line, column}) do + document = reducer.analysis.document + + module_length = + module_name + |> Ast.Module.name() + |> String.length() + + Range.new( + Position.new(document, line, column), + Position.new(document, line, column + module_length) + ) + end + + defp block_range(document, ast) do + case Ast.Range.fetch(ast, document) do + {:ok, range} -> range + _ -> nil + end + end +end diff --git a/forge/lib/forge/search/indexer/extractors/module_attribute.ex b/forge/lib/forge/search/indexer/extractors/module_attribute.ex new file mode 100644 index 00000000..c63315ca --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/module_attribute.ex @@ -0,0 +1,107 @@ +defmodule Forge.Search.Indexer.Extractors.ModuleAttribute do + @moduledoc """ + Extracts module attribute definitions and references from AST + """ + + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer + alias Forge.Search.Subject + + require Logger + + # Finds module attribute usages + def extract({:@, _, [{attr_name, _, nil}]}, %Reducer{} = reducer) do + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + reference = + Entry.reference( + reducer.analysis.document.path, + block, + Subject.module_attribute(current_module, attr_name), + :module_attribute, + reference_range(reducer, attr_name), + Application.get_application(current_module) + ) + + {:ok, reference} + + :error -> + :ignored + end + end + + # an attribute being typed above an already existing attribute will have the name `@`, which we ignore + # example: + # @| + # @callback foo() :: :ok + def extract({:@, _, [{:@, _, _attr_value}]}, %Reducer{}) do + :ignored + end + + # Finds module attribute definitions @foo 3 + def extract({:@, _, [{attr_name, _, _attr_value}]} = attr, %Reducer{} = reducer) do + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + definition = + Entry.definition( + reducer.analysis.document.path, + block, + Subject.module_attribute(current_module, attr_name), + :module_attribute, + definition_range(reducer, attr), + Application.get_application(current_module) + ) + + {:ok, definition} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp reference_range(%Reducer{} = reducer, attr_name) do + document = reducer.analysis.document + + name_length = + attr_name + |> Atom.to_string() + |> String.length() + + {start_line, start_column} = reducer.position + + # add 1 to include the @ character + end_column = start_column + name_length + 1 + + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, start_line, end_column) + ) + end + + defp definition_range(%Reducer{} = reducer, attr_ast) do + document = reducer.analysis.document + + [line: start_line, column: start_column] = Sourceror.get_start_position(attr_ast) + + end_line = Sourceror.get_end_line(attr_ast) + {:ok, line_text} = Forge.Document.fetch_text_at(document, end_line) + # add one because lsp positions are one-based + end_column = String.length(line_text) + 1 + + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, end_line, end_column) + ) + end +end diff --git a/forge/lib/forge/search/indexer/extractors/struct_definition.ex b/forge/lib/forge/search/indexer/extractors/struct_definition.ex new file mode 100644 index 00000000..4376153c --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/struct_definition.ex @@ -0,0 +1,35 @@ +defmodule Forge.Search.Indexer.Extractors.StructDefinition do + alias Forge.Ast + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer + + def extract({:defstruct, _, [_fields]} = definition, %Reducer{} = reducer) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + range = Ast.Range.fetch!(definition, document) + + entry = + Entry.definition( + document.path, + block, + current_module, + :struct, + range, + Application.get_application(current_module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end +end diff --git a/forge/lib/forge/search/indexer/extractors/struct_reference.ex b/forge/lib/forge/search/indexer/extractors/struct_reference.ex new file mode 100644 index 00000000..38c401f3 --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/struct_reference.ex @@ -0,0 +1,93 @@ +defmodule Forge.Search.Indexer.Extractors.StructReference do + alias Forge.Ast + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer + alias Forge.Search.Subject + + require Logger + + @struct_fn_names [:struct, :struct!] + + # Handles usages via an alias, e.g. x = %MyStruct{...} or %__MODULE__{...} + def extract( + {:%, _, [struct_alias, {:%{}, _, _struct_args}]} = reference, + %Reducer{} = reducer + ) do + case expand_alias(struct_alias, reducer) do + {:ok, struct_module} -> + {:ok, entry(reducer, struct_module, reference)} + + _ -> + :ignored + end + end + + # Call to Kernel.struct with a fully qualified module e.g. Kernel.struct(MyStruct, ...) + def extract( + {{:., _, [kernel_alias, struct_fn_name]}, _, [struct_alias | _]} = reference, + %Reducer{} = reducer + ) + when struct_fn_name in @struct_fn_names do + with {:ok, Kernel} <- expand_alias(kernel_alias, reducer), + {:ok, struct_module} <- expand_alias(struct_alias, reducer) do + {:ok, entry(reducer, struct_module, reference)} + else + _ -> + :ignored + end + end + + # handles calls to Kernel.struct e.g. struct(MyModule) or struct(MyModule, foo: 3) + def extract({struct_fn_name, _, [struct_alias | _] = args} = reference, %Reducer{} = reducer) + when struct_fn_name in @struct_fn_names do + reducer_position = Reducer.position(reducer) + imports = Analyzer.imports_at(reducer.analysis, reducer_position) + arity = length(args) + + with true <- Enum.member?(imports, {Kernel, struct_fn_name, arity}), + {:ok, struct_module} <- expand_alias(struct_alias, reducer) do + {:ok, entry(reducer, struct_module, reference)} + else + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp entry(%Reducer{} = reducer, struct_module, reference) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + subject = Subject.module(struct_module) + + Entry.reference( + document.path, + block, + subject, + :struct, + Ast.Range.fetch!(reference, document), + Application.get_application(struct_module) + ) + end + + defp expand_alias({:__aliases__, _, struct_alias}, %Reducer{} = reducer) do + Analyzer.expand_alias(struct_alias, reducer.analysis, Reducer.position(reducer)) + end + + defp expand_alias({:__MODULE__, _, _}, %Reducer{} = reducer) do + Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + end + + defp expand_alias(alias, %Reducer{} = reducer) do + {line, column} = reducer.position + + Logger.error( + "Could not expand alias: #{inspect(alias)} at #{reducer.analysis.document.path} #{line}:#{column}" + ) + + :error + end +end diff --git a/forge/lib/forge/search/indexer/extractors/variable.ex b/forge/lib/forge/search/indexer/extractors/variable.ex new file mode 100644 index 00000000..9a6519d6 --- /dev/null +++ b/forge/lib/forge/search/indexer/extractors/variable.ex @@ -0,0 +1,249 @@ +defmodule Forge.Search.Indexer.Extractors.Variable do + alias Forge.Ast + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer + + @defs [:def, :defmacro, :defp, :defmacrop] + + def extract( + {def, _, [{:when, _, [{_fn_name, _, params} | when_args]}, body]}, + %Reducer{} = reducer + ) + when def in @defs do + entries = extract_definitions(params, reducer) ++ extract_references(when_args, reducer) + {:ok, entries, body} + end + + def extract({def, _, [{_fn_name, _, params}, body]}, %Reducer{} = reducer) + when def in @defs do + entries = extract_definitions(params, reducer) + + {:ok, entries, body} + end + + # Stab operator x -> body + def extract({:->, _, [params, body]}, %Reducer{} = reducer) do + entries = extract_definitions(params, reducer) ++ extract_in_definitions(params, reducer) + + {:ok, entries, List.wrap(body)} + end + + # with match operator. with {:ok, var} <- something() + def extract({:<-, _, [left, right]}, %Reducer{} = reducer) do + entries = extract_definitions(left, reducer) + + {:ok, entries, List.wrap(right)} + end + + # Match operator left = right + def extract({:=, _, [left, right]}, %Reducer{} = reducer) do + definitions = extract_definitions(left, reducer) + + {:ok, definitions, List.wrap(right)} + end + + # String interpolations "#{foo}" + def extract( + {:<<>>, _, [{:"::", _, [{{:., _, [Kernel, :to_string]}, _, body}, {:binary, _, _}]}]}, + %Reducer{} + ) do + {:ok, [], body} + end + + # Test declarations + def extract( + {:test, _metadata, + [ + {:__block__, [delimiter: "\"", line: 3, column: 8], ["my test"]}, + args, + body + ]}, + %Reducer{} = reducer + ) do + entries = extract_definitions(args, reducer) + {:ok, entries, body} + end + + def extract({:binary, _, _}, %Reducer{}) do + :ignored + end + + def extract({:@, _, _}, %Reducer{}) do + {:ok, nil, nil} + end + + # Generic variable reference + def extract({var_name, _, _} = ast, %Reducer{} = reducer) when is_atom(var_name) do + case extract_reference(ast, reducer, get_current_app(reducer)) do + %Entry{} = entry -> {:ok, entry} + _ -> :ignored + end + end + + # Pin operator ^pinned_variable + def extract({:^, _, [reference]}, %Reducer{} = reducer) do + reference = extract_reference(reference, reducer, get_current_app(reducer)) + + {:ok, reference, nil} + end + + def extract(_ast, _reducer) do + :ignored + end + + defp extract_definitions(ast, reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_definition(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + {%Entry{} = entry, ast} -> + {ast, [entry | acc]} + + {entries, ast} when is_list(entries) -> + {ast, entries ++ acc} + + {_, ast} -> + {ast, acc} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + # the pin operator is always on the left side of a pattern match, but it's + # not defining a variable, just referencing one. + defp extract_definition({:^, _, [reference]}, %Reducer{} = reducer, current_app) do + reference = extract_reference(reference, reducer, current_app) + + {reference, nil} + end + + # unquote(expression) + defp extract_definition({:unquote, _, [expr]}, %Reducer{} = reducer, current_app) do + reference = extract_reference(expr, reducer, current_app) + {reference, nil} + end + + defp extract_definition({:@, _, _}, %Reducer{}, _current_app) do + {nil, []} + end + + # when clauses actually contain parameters and references + defp extract_definition({:when, _, when_args}, %Reducer{} = reducer, _current_app) do + {definitions, references} = + Enum.split_with(when_args, fn {_, _, context} -> is_atom(context) end) + + definitions = extract_definitions(definitions, reducer) + references = extract_references(references, reducer) + + {Enum.reverse(definitions ++ references), nil} + end + + # This is an effect of string interpolation + defp extract_definition({:binary, _metadata, nil}, _reducer, _current_app) do + nil + end + + defp extract_definition({var_name, _metadata, nil} = ast, reducer, current_app) do + if used_variable?(var_name) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + Entry.definition( + document.path, + block, + var_name, + :variable, + Ast.Range.fetch!(ast, document), + current_app + ) + end + end + + defp extract_definition(_, _reducer, _current_app), do: nil + + defp extract_references(ast, reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_reference(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + defp extract_reference({var_name, _metadata, nil} = ast, reducer, current_app) do + if used_variable?(var_name) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + Entry.reference( + document.path, + block, + var_name, + :variable, + Ast.Range.fetch!(ast, document), + current_app + ) + end + end + + defp extract_reference(_, _, _) do + nil + end + + # extracts definitions like e in SomeException -> + defp extract_in_definitions(ast, %Reducer{} = reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_in_definition(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + defp extract_in_definition( + [[{:in, _, [definition, _right]}], _body], + %Reducer{} = reducer, + current_app + ) do + extract_definition(definition, reducer, current_app) + end + + defp extract_in_definition(_ast, %Reducer{}, _current_app), do: nil + + defp get_current_app(%Reducer{} = reducer) do + with {:ok, module} <- Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + Application.get_application(module) + end + end + + defp used_variable?(variable_name) do + not (variable_name + |> Atom.to_string() + |> String.starts_with?("_")) + end +end diff --git a/forge/lib/forge/search/indexer/metadata.ex b/forge/lib/forge/search/indexer/metadata.ex new file mode 100644 index 00000000..369144dd --- /dev/null +++ b/forge/lib/forge/search/indexer/metadata.ex @@ -0,0 +1,74 @@ +defmodule Forge.Search.Indexer.Metadata do + @moduledoc """ + Utilities for extracting location information from AST metadata nodes. + """ + def location({_, metadata, _} = ast) do + if Keyword.has_key?(metadata, :do) do + position = position(metadata) + block_start = position(metadata, :do) + block_end = position(metadata, :end_of_expression) || position(metadata, :end) + {:block, position, block_start, block_end} + else + maybe_handle_terse_function(ast) + end + end + + def location(_unknown) do + {:expression, nil} + end + + def position(keyword) do + line = Keyword.get(keyword, :line) + column = Keyword.get(keyword, :column) + + case {line, column} do + {nil, nil} -> + nil + + position -> + position + end + end + + def position(keyword, key) do + keyword + |> Keyword.get(key, []) + |> position() + end + + @defines [:def, :defp, :defmacro, :defmacrop, :fn] + # a terse function is one without a do/end block + defp maybe_handle_terse_function({define, metadata, [_name_and_args | [[block | _]]]}) + when define in @defines do + block_location(block, metadata) + end + + defp maybe_handle_terse_function({:fn, metadata, _} = ast) do + block_location(ast, metadata) + end + + defp maybe_handle_terse_function({_, metadata, _}) do + {:expression, position(metadata)} + end + + defp block_location(block, metadata) do + case Sourceror.get_range(block) do + %{start: start_pos, end: end_pos} -> + position = position(metadata) + {:block, position, keyword_to_position(start_pos), keyword_to_position(end_pos)} + + _ -> + {:expression, position(metadata)} + end + end + + defp keyword_to_position(keyword) do + case Keyword.take(keyword, [:line, :column]) do + [line: line, column: column] when is_number(line) and is_number(column) -> + {line, column} + + _ -> + nil + end + end +end diff --git a/forge/lib/forge/search/indexer/module.ex b/forge/lib/forge/search/indexer/module.ex new file mode 100644 index 00000000..ac417f46 --- /dev/null +++ b/forge/lib/forge/search/indexer/module.ex @@ -0,0 +1,27 @@ +defmodule Forge.Search.Indexer.Module do + alias Forge.Search.Indexer + + def index(module) do + with true <- indexable?(module), + {:ok, path, source} <- source_file_path(module) do + Indexer.Source.index(path, source) + else + _ -> + nil + end + end + + defp source_file_path(module) do + with {:ok, file_path} <- Keyword.fetch(module.__info__(:compile), :source), + {:ok, contents} <- File.read(file_path) do + {:ok, file_path, contents} + end + end + + defp indexable?(Kernel.SpecialForms), do: false + + defp indexable?(module) do + module_string = to_string(module) + String.starts_with?(module_string, "Elixir.") + end +end diff --git a/forge/lib/forge/search/indexer/quoted.ex b/forge/lib/forge/search/indexer/quoted.ex new file mode 100644 index 00000000..18e3fb37 --- /dev/null +++ b/forge/lib/forge/search/indexer/quoted.ex @@ -0,0 +1,29 @@ +defmodule Forge.Search.Indexer.Quoted do + alias Forge.Ast.Analysis + alias Forge.ProcessCache + alias Forge.Search.Indexer.Source.Reducer + + require ProcessCache + + def index_with_cleanup(%Analysis{} = analysis) do + ProcessCache.with_cleanup do + index(analysis) + end + end + + def index(analysis, extractors \\ nil) + + def index(%Analysis{valid?: true} = analysis, extractors) do + {_, reducer} = + Macro.prewalk(analysis.ast, Reducer.new(analysis, extractors), fn elem, reducer -> + {reducer, elem} = Reducer.reduce(reducer, elem) + {elem, reducer} + end) + + {:ok, Reducer.entries(reducer)} + end + + def index(%Analysis{valid?: false}, _extractors) do + {:ok, []} + end +end diff --git a/forge/lib/forge/search/indexer/source.ex b/forge/lib/forge/search/indexer/source.ex new file mode 100644 index 00000000..d7338533 --- /dev/null +++ b/forge/lib/forge/search/indexer/source.ex @@ -0,0 +1,19 @@ +defmodule Forge.Search.Indexer.Source do + alias Forge.Ast + alias Forge.Document + alias Forge.Search.Indexer + + require Logger + + def index(path, source, extractors \\ nil) do + path + |> Document.new(source, 1) + |> index_document(extractors) + end + + def index_document(%Document{} = document, extractors \\ nil) do + document + |> Ast.analyze() + |> Indexer.Quoted.index(extractors) + end +end diff --git a/forge/lib/forge/search/indexer/source/block.ex b/forge/lib/forge/search/indexer/source/block.ex new file mode 100644 index 00000000..e2ff9b13 --- /dev/null +++ b/forge/lib/forge/search/indexer/source/block.ex @@ -0,0 +1,17 @@ +defmodule Forge.Search.Indexer.Source.Block do + @moduledoc """ + A struct that represents a block of source code + """ + + defstruct [:starts_at, :ends_at, :id, :parent_id] + alias Forge.Identifier + + def root do + %__MODULE__{id: :root} + end + + def new(starts_at, ends_at) do + id = Identifier.next_global!() + %__MODULE__{starts_at: starts_at, ends_at: ends_at, id: id} + end +end diff --git a/forge/lib/forge/search/indexer/source/reducer.ex b/forge/lib/forge/search/indexer/source/reducer.ex new file mode 100644 index 00000000..e99fc235 --- /dev/null +++ b/forge/lib/forge/search/indexer/source/reducer.ex @@ -0,0 +1,187 @@ +defmodule Forge.Search.Indexer.Source.Reducer do + @moduledoc """ + A module and struct that can reduce over elixir AST via Macro.prewalk/3 + + The reducer keeps track of blocks and parent / child relationships so extractors don't have to concern themselves + with the AST's overall structure, and can focus on extracting content from it. + """ + + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Block + + defstruct [:analysis, :entries, :position, :blocks, :block_hierarchy, extractors: []] + + @extractors [ + Extractors.Module, + Extractors.ModuleAttribute, + Extractors.FunctionDefinition, + Extractors.FunctionReference, + Extractors.StructDefinition, + Extractors.StructReference, + Extractors.EctoSchema + ] + + def new(%Analysis{} = analysis, extractors \\ nil) do + %__MODULE__{ + analysis: analysis, + block_hierarchy: %{root: %{}}, + blocks: [Block.root()], + entries: [], + extractors: extractors || @extractors, + position: {0, 0} + } + end + + def human_location(%__MODULE__{} = reducer) do + {line, column} = reducer.position + path = reducer.analysis.document.path + "#{path} #{line}:#{column}" + end + + def entries(%__MODULE__{} = reducer) do + [hierarchy(reducer) | Enum.reverse(reducer.entries)] + end + + def skip(meta) do + Keyword.put(meta, :__skipped__, true) + end + + def skip?({_, meta, _}) do + Keyword.get(meta, :__skipped__, false) + end + + def skip?(_), do: false + + def reduce(%__MODULE__{} = reducer, element) do + if skip?(element) do + {reducer, element} + else + do_reduce(reducer, element) + end + end + + def position(%__MODULE__{} = reducer) do + {line, column} = reducer.position + Position.new(reducer.analysis.document, line, column) + end + + defp hierarchy(%__MODULE__{} = reducer) do + Entry.block_structure(reducer.analysis.document.path, reducer.block_hierarchy) + end + + defp do_reduce(%__MODULE__{} = reducer, element) do + case Metadata.location(element) do + {:block, position, block_start, block_end} -> + block = Block.new(block_start, block_end) + + reducer + |> update_position(position) + |> maybe_pop_block() + |> push_block(block) + |> apply_extractors(element) + + {:expression, position} -> + reducer + |> update_position(position) + |> maybe_pop_block() + |> apply_extractors(element) + end + end + + defp apply_extractors(%__MODULE__{} = reducer, element) do + Enum.reduce(reducer.extractors, {reducer, element}, fn detector_module, {reducer, element} -> + case detector_module.extract(element, reducer) do + {:ok, entry} -> + reducer = push_entry(reducer, entry) + {reducer, element} + + {:ok, entry, elem} -> + reducer = push_entry(reducer, entry) + + {reducer, elem} + + :ignored -> + {reducer, element} + end + end) + end + + defp update_position(%__MODULE__{} = reducer, nil) do + reducer + end + + defp update_position(%__MODULE__{} = reducer, position) do + Map.put(reducer, :position, position) + end + + def current_block(%__MODULE__{} = reducer) do + List.first(reducer.blocks) + end + + defp push_block(%__MODULE__{} = reducer, %Block{} = block) do + parent = current_block(reducer) + block = %Block{block | parent_id: parent.id} + id_path = Enum.reduce(reducer.blocks, [], fn block, acc -> [block.id | acc] end) + + hierarchy = + update_in(reducer.block_hierarchy, id_path, fn current -> + Map.put(current, block.id, %{}) + end) + + %__MODULE__{reducer | blocks: [block | reducer.blocks], block_hierarchy: hierarchy} + end + + # you never pop the root block in a document + defp pop_block(%__MODULE__{blocks: [%Block{id: :root}]} = reducer), do: reducer + + defp pop_block(%__MODULE__{} = reducer) do + [_ | rest] = reducer.blocks + %__MODULE__{reducer | blocks: rest} + end + + # The root block in the document goes on forever + defp block_ended?(%__MODULE__{blocks: [%Block{id: :root}]}), do: false + + defp block_ended?(%__MODULE__{} = reducer) do + %Block{} = block = current_block(reducer) + + {ends_at_line, ends_at_column} = block.ends_at + + {current_line, current_column} = reducer.position + + cond do + current_line == ends_at_line and current_column > ends_at_column -> + true + + current_line > ends_at_line -> + true + + true -> + false + end + end + + defp push_entry(%__MODULE__{} = reducer, entries) when is_list(entries) do + Enum.reduce(entries, reducer, &push_entry(&2, &1)) + end + + defp push_entry(%__MODULE__{} = reducer, %Entry{} = entry) do + %__MODULE__{reducer | entries: [entry | reducer.entries]} + end + + defp push_entry(%__MODULE__{} = reducer, _), do: reducer + + defp maybe_pop_block(%__MODULE__{} = reducer) do + if block_ended?(reducer) do + reducer + |> pop_block() + |> maybe_pop_block() + else + reducer + end + end +end diff --git a/forge/lib/forge/search/store.ex b/forge/lib/forge/search/store.ex new file mode 100644 index 00000000..87723269 --- /dev/null +++ b/forge/lib/forge/search/store.ex @@ -0,0 +1,294 @@ +defmodule Forge.Search.Store do + @moduledoc """ + A persistent store for search entries + """ + + alias Forge.Project + + alias Forge.Api + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store + alias Forge.Search.Store.State + + @type index_state :: :empty | :stale + @type existing_entries :: [Entry.t()] + @type new_entries :: [Entry.t()] + @type updated_entries :: [Entry.t()] + @type paths_to_delete :: [Path.t()] + @typedoc """ + A function that creates indexes when none is detected + """ + @type create_index :: + (project :: Project.t() -> + {:ok, new_entries} | {:error, term()}) + + @typedoc """ + A function that takes existing entries and refreshes them if necessary + """ + @type refresh_index :: + (project :: Project.t(), entries :: existing_entries -> + {:ok, new_entries, paths_to_delete} | {:error, term()}) + + @backend Application.compile_env(:remote_control, :search_store_backend, Store.Backends.Ets) + @flush_interval_ms Application.compile_env( + :remote_control, + :search_store_quiescent_period_ms, + 2500 + ) + + import Api.Messages + use GenServer + require Logger + + def stop do + GenServer.stop(__MODULE__) + end + + def loaded? do + GenServer.call(__MODULE__, :loaded?) + end + + def replace(entries) do + GenServer.call(__MODULE__, {:replace, entries}) + end + + @spec exact(Entry.subject_query(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def exact(subject \\ :_, constraints) do + call_or_default({:exact, subject, constraints}, []) + end + + @spec prefix(String.t(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def prefix(prefix, constraints) do + call_or_default({:prefix, prefix, constraints}, []) + end + + @spec parent(Entry.t()) :: {:ok, Entry.t()} | {:error, term()} + def parent(%Entry{} = entry) do + call_or_default({:parent, entry}, nil) + end + + @spec siblings(Entry.t()) :: {:ok, [Entry.t()]} | {:error, term()} + def siblings(%Entry{} = entry) do + call_or_default({:siblings, entry}, []) + end + + @spec fuzzy(Entry.subject(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def fuzzy(subject, constraints) do + call_or_default({:fuzzy, subject, constraints}, []) + end + + def clear(path) do + GenServer.call(__MODULE__, {:update, path, []}) + end + + def update(path, entries) do + GenServer.call(__MODULE__, {:update, path, entries}) + end + + def destroy do + GenServer.call(__MODULE__, :destroy) + end + + def enable do + GenServer.call(__MODULE__, :enable) + end + + @spec start_link(Project.t(), create_index, refresh_index, module()) :: GenServer.on_start() + def start_link(%Project{} = project, create_index, refresh_index, backend) do + GenServer.start_link(__MODULE__, [project, create_index, refresh_index, backend], + name: __MODULE__ + ) + end + + def child_spec(init_args) when is_list(init_args) do + %{ + id: __MODULE__, + start: {__MODULE__, :start_link, normalize_init_args(init_args)} + } + end + + defp normalize_init_args([create_index, refresh_index]) do + normalize_init_args([Forge.get_project(), create_index, refresh_index]) + end + + defp normalize_init_args([%Project{} = project, create_index, refresh_index]) do + normalize_init_args([project, create_index, refresh_index, backend()]) + end + + defp normalize_init_args([%Project{}, create_index, refresh_index, backend] = args) + when is_function(create_index, 1) and is_function(refresh_index, 2) and is_atom(backend) do + args + end + + @impl GenServer + def init([%Project{} = project, create_index, update_index, backend]) do + Process.flag(:fullsweep_after, 5) + schedule_gc() + # I've found that if indexing happens before the first compile, for some reason + # the compilation is 4x slower than if indexing happens after it. I was + # unable to figure out why this is the case, and I looked extensively, so instead + # we have this bandaid. We wait for the first compilation to complete, and then + # the search store enables itself, at which point we index the code. + + Engine.register_listener(self(), project_compiled()) + state = State.new(project, create_index, update_index, backend) + {:ok, state} + end + + @impl GenServer + # enable ourselves when the project is force compiled + def handle_info(project_compiled(), %State{} = state) do + {:noreply, enable(state)} + end + + def handle_info(project_compiled(), {_, _} = state) do + # we're already enabled, no need to do anything + {:noreply, state} + end + + # handle the result from `State.async_load/1` + def handle_info({ref, result}, {update_ref, %State{async_load_ref: ref} = state}) do + {:noreply, {update_ref, State.async_load_complete(state, result)}} + end + + def handle_info(:flush_updates, {_, %State{} = state}) do + {:ok, state} = State.flush_buffered_updates(state) + ref = schedule_flush() + {:noreply, {ref, state}} + end + + def handle_info(:gc, state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + def handle_info(_, state) do + {:noreply, state} + end + + @impl GenServer + def handle_call(:enable, _from, %State{} = state) do + {:reply, :ok, enable(state)} + end + + def handle_call(:enable, _from, state) do + {:reply, :ok, state} + end + + def handle_call({:replace, entities}, _from, {ref, %State{} = state}) do + {reply, new_state} = + case State.replace(state, entities) do + {:ok, new_state} -> + {:ok, State.drop_buffered_updates(new_state)} + + {:error, _} = error -> + {error, state} + end + + {:reply, reply, {ref, new_state}} + end + + def handle_call({:exact, subject, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.exact(state, subject, constraints), {ref, state}} + end + + def handle_call({:prefix, prefix, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.prefix(state, prefix, constraints), {ref, state}} + end + + def handle_call({:fuzzy, subject, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.fuzzy(state, subject, constraints), {ref, state}} + end + + def handle_call({:update, path, entries}, _from, {ref, %State{} = state}) do + {reply, new_ref, new_state} = do_update(state, ref, path, entries) + + {:reply, reply, {new_ref, new_state}} + end + + def handle_call({:parent, entry}, _from, {_, %State{} = state} = orig_state) do + parent = State.parent(state, entry) + {:reply, parent, orig_state} + end + + def handle_call({:siblings, entry}, _from, {_, %State{} = state} = orig_state) do + siblings = State.siblings(state, entry) + {:reply, siblings, orig_state} + end + + def handle_call(:on_stop, _, {ref, %State{} = state}) do + {:ok, state} = State.flush_buffered_updates(state) + + State.drop(state) + {:reply, :ok, {ref, state}} + end + + def handle_call(:loaded?, _, {ref, %State{loaded?: loaded?} = state}) do + {:reply, loaded?, {ref, state}} + end + + def handle_call(:loaded?, _, %State{loaded?: loaded?} = state) do + # We're not enabled yet, but we can still reply to the query + {:reply, loaded?, state} + end + + def handle_call(:destroy, _, {ref, %State{} = state}) do + new_state = State.destroy(state) + {:reply, :ok, {ref, new_state}} + end + + def handle_call(message, _from, %State{} = state) do + Logger.warning("Received #{inspect(message)}, but the search store isn't enabled yet.") + {:reply, {:error, {:not_enabled, message}}, state} + end + + @impl GenServer + def terminate(_reason, {_, state}) do + {:ok, state} = State.flush_buffered_updates(state) + {:noreply, state} + end + + defp backend do + @backend + end + + defp do_update(state, old_ref, path, entries) do + {:ok, schedule_flush(old_ref), State.buffer_updates(state, path, entries)} + end + + defp schedule_flush(ref) when is_reference(ref) do + Process.cancel_timer(ref) + schedule_flush() + end + + defp schedule_flush(_) do + schedule_flush() + end + + defp schedule_flush do + Process.send_after(self(), :flush_updates, @flush_interval_ms) + end + + defp enable(%State{} = state) do + state = State.async_load(state) + :persistent_term.put({__MODULE__, :enabled?}, true) + {nil, state} + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end + + defp call_or_default(call, default) do + if enabled?() do + GenServer.call(__MODULE__, call) + else + default + end + end + + defp enabled? do + :persistent_term.get({__MODULE__, :enabled?}, false) + end +end diff --git a/forge/lib/forge/search/store/backend.ex b/forge/lib/forge/search/store/backend.ex new file mode 100644 index 00000000..d7445372 --- /dev/null +++ b/forge/lib/forge/search/store/backend.ex @@ -0,0 +1,109 @@ +defmodule Forge.Search.Store.Backend do + @moduledoc """ + A behaviour for search store backends + """ + alias Forge.Project + alias Forge.Search.Indexer.Entry + @type version :: pos_integer() + + @type priv_state :: term() + @type load_state :: :empty | :stale + @type field_name :: atom() + @type name :: term + @type metadata :: %{ + schema_version: version(), + types: [Entry.entry_type()], + subtypes: [Entry.entry_subtype()] + } + + @type wildcard :: :_ + @type subject_query :: Entry.subject() | wildcard() + @type type_query :: Entry.entry_type() | wildcard() + @type subtype_query :: Entry.entry_subtype() | wildcard() + @type block_structure :: %{Entry.block_id() => block_structure()} | %{} + @type path_structures :: %{Path.t() => block_structure()} + @type accumulator :: any() + @type reducer_fun :: (Entry.t(), accumulator() -> accumulator()) + + @doc """ + Create a new backend. + This function must return quickly, as it's called from the store process + """ + @callback new(Project.t()) :: {:ok, priv_state()} | {:error, any()} + + @doc """ + Prepares the backend for use. + This receives the result of `new/1`, and sets up the store for use. When this function + returns, the backend is considered ready for use. + """ + @callback prepare(priv_state()) :: {:ok, load_state()} + + @doc """ + Synchronizes the backend to the file system (optional) + """ + @callback sync(Project.t()) :: :ok | {:error, any()} + + @doc """ + Inserts all entries into the backend + """ + @callback insert([Entry.t()]) :: :ok + + @doc """ + Drops all data from the backend, but keeps the underlying structure + """ + @callback drop() :: boolean() + + @doc """ + Drops all data from the backend, and disposes of any underlying structure + """ + @callback destroy(Project.t()) :: :ok + + @doc """ + Applies a reducer function to the backend's entries + """ + @callback reduce(accumulator(), reducer_fun()) :: accumulator() + + @doc """ + Replaces all the entries in the store with those passed in + """ + @callback replace_all([Entry.t()]) :: :ok + + @doc """ + Deletes all entries whose path is equal to the one passed in. + """ + @callback delete_by_path(Path.t()) :: {:ok, [Entry.entry_id()]} | {:error, any()} + + @doc """ + Returns the block structure for the given path + """ + @callback structure_for_path(Path.t()) :: {:ok, block_structure()} | :error + + @doc """ + Finds all entries + """ + @callback find_by_subject(subject_query(), type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Finds all entries by prefix + """ + @callback find_by_prefix(subject_query(), type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Finds entries whose ref attribute is in the given list + """ + @callback find_by_ids([Entry.entry_id()], type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Returns all the sibling elements of the given element. + + Elements are returned in the order they appear in the source + """ + @callback siblings(Entry.t()) :: [Entry.t()] + + @doc """ + Returns the parent block of the given entry, or :error if there is no parent + """ + @callback parent(Entry.t()) :: {:ok, Entry.t()} | :error + + @optional_callbacks sync: 1 +end diff --git a/forge/lib/forge/search/store/backends/ets.ex b/forge/lib/forge/search/store/backends/ets.ex new file mode 100644 index 00000000..72d4bf51 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets.ex @@ -0,0 +1,246 @@ +defmodule Forge.Search.Store.Backends.Ets do + alias Forge.Project + + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backend + alias Forge.Search.Store.Backends.Ets.State + + use GenServer + + @behaviour Backend + + @impl Backend + def new(%Project{}) do + {:ok, Process.whereis(__MODULE__)} + end + + @impl Backend + def prepare(pid) do + GenServer.call(pid, :prepare, :infinity) + end + + @impl Backend + def insert(entries) do + GenServer.call(genserver_name(), {:insert, [entries]}, :infinity) + end + + @impl Backend + def drop do + GenServer.call(genserver_name(), {:drop, []}) + end + + @impl Backend + def destroy(%Project{} = project) do + name = genserver_name(project) + + if pid = GenServer.whereis(name) do + GenServer.call(pid, {:destroy, []}) + end + + :ok + end + + def destroy_all(%Project{} = project) do + State.destroy_all(project) + end + + @impl Backend + def reduce(acc, reducer_fun) do + GenServer.call(genserver_name(), {:reduce, [acc, reducer_fun]}, :infinity) + end + + @impl Backend + def replace_all(entries) do + GenServer.call(genserver_name(), {:replace_all, [entries]}, :infinity) + end + + @impl Backend + def delete_by_path(path) do + GenServer.call(genserver_name(), {:delete_by_path, [path]}) + end + + @impl Backend + def find_by_subject(subject, type, subtype) do + GenServer.call(genserver_name(), {:find_by_subject, [subject, type, subtype]}) + end + + @impl Backend + def find_by_prefix(prefix, type, subtype) do + GenServer.call(genserver_name(), {:find_by_prefix, [prefix, type, subtype]}) + end + + @impl Backend + def find_by_ids(ids, type, subtype) do + GenServer.call(genserver_name(), {:find_by_ids, [ids, type, subtype]}) + end + + @impl Backend + def structure_for_path(path) do + GenServer.call(genserver_name(), {:structure_for_path, [path]}) + end + + @impl Backend + def siblings(%Entry{} = entry) do + GenServer.call(genserver_name(), {:siblings, [entry]}) + end + + @impl Backend + def parent(%Entry{} = entry) do + GenServer.call(genserver_name(), {:parent, [entry]}) + end + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: __MODULE__) + end + + def start_link do + start_link(Forge.get_project()) + end + + def child_spec([%Project{}] = init_args) do + %{id: __MODULE__, start: {__MODULE__, :start_link, init_args}} + end + + def child_spec(_) do + child_spec([Forge.get_project()]) + end + + @impl GenServer + def init([%Project{} = project]) do + Process.flag(:fullsweep_after, 5) + :ok = connect_to_project_nodes(project) + {:ok, project, {:continue, :try_for_leader}} + end + + @impl GenServer + def handle_continue(:try_for_leader, %Project{} = project) do + leader_name = leader_name(project) + + with :undefined <- :global.whereis_name(leader_name), + :ok <- become_leader(project) do + {:noreply, create_leader(project)} + else + _ -> + {:noreply, follow_leader(project)} + end + end + + @impl GenServer + def handle_call(:prepare, _from, %State{} = state) do + case State.prepare(state) do + {:error, :not_leader} = error -> + {:stop, :normal, error, state} + + {reply, new_state} -> + {:reply, reply, new_state} + end + end + + def handle_call({function_name, arguments}, _from, %State{} = state) do + arguments = [state | arguments] + reply = apply(State, function_name, arguments) + {:reply, reply, state} + end + + @impl GenServer + def handle_info({:EXIT, _, _reason}, %State{leader?: true} = state) do + # ets died, and we own it. Restart it + + {:noreply, create_leader(state.project)} + end + + def handle_info({:DOWN, _ref, :process, pid, _reason}, %State{leader_pid: pid} = state) do + {:noreply, state.project, {:continue, :try_for_leader}} + end + + def handle_info({:global_name_conflict, {:ets_search, _}}, %State{} = state) do + # This clause means we were randomly notified by the call to + # :global.random_notify_name. We've been selected to be the leader! + new_state = become_leader(state.project) + {:noreply, new_state} + end + + def handle_info(:gc, %State{} = state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + @impl GenServer + def terminate(_reason, %State{} = state) do + State.terminate(state) + state + end + + # Private + + defp leader_name(%Project{} = project) do + {:ets_search, Project.name(project)} + end + + defp genserver_name do + genserver_name(Forge.get_project()) + end + + defp genserver_name(%Project{} = project) do + {:global, leader_name(project)} + end + + defp become_leader(%Project{} = project) do + leader_name = leader_name(project) + :global.trans(leader_name, fn -> do_become_leader(project) end, [], 0) + end + + defp do_become_leader(%Project{} = project) do + leader_name = leader_name(project) + + with :undefined <- :global.whereis_name(leader_name), + :yes <- :global.register_name(leader_name, self(), &:global.random_notify_name/3) do + Process.flag(:trap_exit, true) + :ok + else + _ -> + :error + end + end + + defp follow_leader(%Project{} = project) do + leader_pid = :global.whereis_name(leader_name(project)) + Process.monitor(leader_pid) + State.new_follower(project, leader_pid) + end + + defp create_leader(%Project{} = project) do + State.new_leader(project) + end + + defp connect_to_project_nodes(%Project{} = project) do + case :erl_epmd.names() do + {:ok, node_names_and_ports} -> + project + |> project_nodes(node_names_and_ports) + |> Enum.each(&Node.connect/1) + + :global.sync() + + _ -> + :ok + end + end + + defp project_nodes(%Project{} = project, node_and_port_list) do + project_name = Project.name(project) + + project_substring = "project-#{project_name}-" + + for {node_name_charlist, _port} <- node_and_port_list, + node_name_string = List.to_string(node_name_charlist), + String.contains?(node_name_string, project_substring) do + :"#{node_name_string}@127.0.0.1" + end + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end +end diff --git a/forge/lib/forge/search/store/backends/ets/schema.ex b/forge/lib/forge/search/store/backends/ets/schema.ex new file mode 100644 index 00000000..08ebd3b7 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/schema.ex @@ -0,0 +1,229 @@ +defmodule Forge.Search.Store.Backends.Ets.Schema do + @moduledoc """ + A use-able module that allows ETS schemas to be created and migrated. + + This module allows users to define ETS key-based schemas for our search backends. These modules + are versioned, and are all stored in their own ETS tables. This is so that a single ETS table can + never have more than one schema. + + Schemas also support migrations. An optional `migrate` function receives old entries and is expected + transform them into the newer version. The results of this function will be loaded into the schema's + ETS table. If an empty list is returned, a full reindex will take place. + """ + defmacro __using__(opts) do + version = Keyword.fetch!(opts, :version) + + quote do + @behaviour unquote(__MODULE__) + @version unquote(version) + alias Forge.Project + import unquote(__MODULE__), only: [defkey: 2] + + def version do + @version + end + + def index_file_name do + "source.index.v#{@version}.ets" + end + + def table_name do + :"lexical_search_v#{@version}" + end + + def table_options do + [:named_table, :set] + end + + def migrate(entries) do + {:ok, entries} + end + + defoverridable migrate: 1, index_file_name: 0, table_options: 0 + end + end + + alias Forge.Project + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backends.Ets.Wal + + import Wal, only: :macros + + @type write_concurrency_alternative :: boolean() | :auto + @type table_tweak :: + :compressed + | {:write_concurrency, write_concurrency_alternative()} + | {:read_concurrency, boolean()} + | {:decentralized_counters, boolean()} + + @type table_option :: :ets.table_type() | table_tweak() + + @type key :: tuple() + @type row :: {key, tuple()} + + @callback index_file_name() :: String.t() + @callback table_options() :: [table_option()] + @callback to_rows(Entry.t()) :: [row()] + @callback migrate([Entry.t()]) :: {:ok, [row()]} | {:error, term()} + + defmacro defkey(name, fields) do + query_keys = Enum.map(fields, fn name -> {name, :_} end) + query_record_name = :"query_#{name}" + + quote location: :keep do + require Record + + Record.defrecord(unquote(name), unquote(fields)) + Record.defrecord(unquote(query_record_name), unquote(name), unquote(query_keys)) + end + end + + @spec entries_to_rows(Enumerable.t(Entry.t()), module()) :: [tuple()] + def entries_to_rows(entries, schema_module) do + entries + |> Stream.flat_map(&schema_module.to_rows(&1)) + |> Enum.reduce(%{}, fn {key, value}, acc -> + Map.update(acc, key, [value], fn old_values -> [value | old_values] end) + end) + |> Enum.to_list() + end + + def load(%Project{} = project, schema_order) do + ensure_unique_versions(schema_order) + + with {:ok, initial_schema, chain} <- upgrade_chain(project, schema_order), + {:ok, wal, table_name, entries} <- load_initial_schema(project, initial_schema) do + handle_upgrade_chain(chain, project, wal, table_name, entries) + else + _ -> + schema_module = List.last(schema_order) + table_name = schema_module.table_name() + ensure_schema_table_exists(table_name, schema_module.table_options()) + + {:ok, new_wal} = Wal.load(project, schema_module.version(), schema_module.table_name()) + + {:ok, new_wal, table_name, :empty} + end + end + + defp load_status([]), do: :empty + defp load_status(_entries), do: :stale + + defp handle_upgrade_chain([_schema_module], _project, wal, table_name, entries) do + # this case is that there are no migrations to perform + # we get a single entry, which is the schema module + + {:ok, wal, table_name, load_status(entries)} + end + + defp handle_upgrade_chain(chain, project, _wal, _table_name, entries) do + with {:ok, schema_module, entries} <- apply_migrations(project, chain, entries), + {:ok, new_wal, dest_table_name} <- populate_schema_table(project, schema_module, entries) do + {:ok, new_wal, dest_table_name, load_status(entries)} + end + end + + defp apply_migrations(_project, [initial], entries) do + {:ok, initial, entries} + end + + defp apply_migrations(project, chain, entries) do + Enum.reduce_while(chain, {:ok, nil, entries}, fn + initial, {:ok, nil, entries} -> + Wal.destroy(project, initial.version()) + {:cont, {:ok, initial, entries}} + + to, {:ok, _, entries} -> + case to.migrate(entries) do + {:ok, new_entries} -> + Wal.destroy(project, to.version()) + {:cont, {:ok, to, new_entries}} + + error -> + {:halt, error} + end + end) + end + + defp populate_schema_table(%Project{} = project, schema_module, entries) do + dest_table_name = schema_module.table_name() + ensure_schema_table_exists(dest_table_name, schema_module.table_options()) + + with {:ok, wal} <- Wal.load(project, schema_module.version(), dest_table_name), + {:ok, new_wal_state} <- do_populate_schema(wal, dest_table_name, entries), + {:ok, checkpoint_wal} <- Wal.checkpoint(new_wal_state) do + {:ok, checkpoint_wal, dest_table_name} + end + end + + defp do_populate_schema(%Wal{} = wal, table_name, entries) do + result = + with_wal wal do + :ets.delete_all_objects(table_name) + :ets.insert(table_name, entries) + end + + case result do + {:ok, new_wal_state, _} -> {:ok, new_wal_state} + error -> error + end + end + + defp ensure_schema_table_exists(table_name, table_options) do + case :ets.whereis(table_name) do + :undefined -> :ets.new(table_name, table_options) + _ -> table_name + end + end + + defp load_initial_schema(%Project{} = project, schema_module) do + table_name = schema_module.table_name() + ensure_schema_table_exists(table_name, schema_module.table_options()) + + case Wal.load(project, schema_module.version(), table_name) do + {:ok, wal} -> {:ok, wal, table_name, :ets.tab2list(table_name)} + error -> error + end + end + + defp upgrade_chain(%Project{} = project, schema_order) do + {_, initial_schema, schemas} = + schema_order + |> Enum.reduce({:not_found, nil, []}, fn + schema_module, {:not_found, nil, _} -> + if Wal.exists?(project, schema_module.version()) do + {:found, schema_module, [schema_module]} + else + {:not_found, nil, []} + end + + schema_module, {:found, initial_schema, chain} -> + {:found, initial_schema, [schema_module | chain]} + end) + + case Enum.reverse(schemas) do + [] -> + :error + + other -> + {:ok, initial_schema, other} + end + end + + defp ensure_unique_versions(schemas) do + Enum.reduce(schemas, %{}, fn schema, seen_versions -> + schema_version = schema.version() + + case seen_versions do + %{^schema_version => previous_schema} -> + message = + "Version Conflict. #{inspect(schema)} had a version that matches #{inspect(previous_schema)}" + + raise ArgumentError.exception(message) + + _ -> + Map.put(seen_versions, schema_version, schema) + end + end) + end +end diff --git a/forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex b/forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex new file mode 100644 index 00000000..5127fe32 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex @@ -0,0 +1,19 @@ +defmodule Forge.Search.Store.Backends.Ets.Schemas.LegacyV0 do + @moduledoc """ + A legacy version of the schema. + + We pushed the initial indexer to main before we added schemas and versioning. + This represents that schema type, hence the non-versioned name. + """ + alias Forge.Search.Store.Backends.Ets.Schema + + use Schema, version: 0 + + def index_file_name do + "source.index.ets" + end + + def to_rows(_) do + [] + end +end diff --git a/forge/lib/forge/search/store/backends/ets/schemas/v1.ex b/forge/lib/forge/search/store/backends/ets/schemas/v1.ex new file mode 100644 index 00000000..f7703360 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/schemas/v1.ex @@ -0,0 +1,79 @@ +defmodule Forge.Search.Store.Backends.Ets.Schemas.V1 do + @moduledoc """ + This schema uses a bit of data duplication in order to achieve good performance. + + It does this by storing data under three different key types. The first type groups references to ids by + path, and is accessible via the `by_path` utility macros. The second, stores data by subject, type, subtype, + path and the elixir and erlang versions. This is what powers exact matching. + Finally, entries are stored by their id, which powers direct lookups, which are used in fuzzy matching. + + """ + + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backends.Ets.Schema + + use Schema, version: 1 + + defkey(:by_id, [:id, :type, :subtype]) + + defkey(:by_subject, [ + :subject, + :type, + :subtype, + :path + ]) + + defkey(:by_path, [:path]) + + def migrate(entries) do + migrated = + entries + |> Stream.filter(fn + {_, %_{type: _, subtype: _, id: _}} -> true + _ -> false + end) + |> Stream.map(fn {_, entry} -> entry end) + |> Schema.entries_to_rows(__MODULE__) + + {:ok, migrated} + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + + [{subject_key, id_key}, {id_key, entry}, {path_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + [:named_table, :ordered_set] + end + + defp to_subject(binary) when is_binary(binary), do: binary + defp to_subject(:_), do: :_ + defp to_subject(atom) when is_atom(atom), do: inspect(atom) + defp to_subject(other), do: to_string(other) +end diff --git a/forge/lib/forge/search/store/backends/ets/schemas/v2.ex b/forge/lib/forge/search/store/backends/ets/schemas/v2.ex new file mode 100644 index 00000000..c044b6d2 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/schemas/v2.ex @@ -0,0 +1,69 @@ +defmodule Forge.Search.Store.Backends.Ets.Schemas.V2 do + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backends.Ets.Schema + + require Entry + use Schema, version: 2 + + defkey(:by_id, [:id, :type, :subtype]) + + defkey(:by_subject, [ + :subject, + :type, + :subtype, + :path + ]) + + defkey(:by_path, [:path]) + defkey(:by_block_id, [:block_id, :path]) + defkey(:structure, [:path]) + + def migrate(_) do + {:ok, []} + end + + def to_rows(%Entry{} = entry) when Entry.is_structure(entry) do + structure_key = structure(path: entry.path) + [{structure_key, entry.subject}] + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + block_key = by_block_id(path: entry.path, block_id: entry.block_id) + + [{id_key, entry}, {subject_key, id_key}, {path_key, id_key}, {block_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + [:named_table, :ordered_set, :compressed] + end + + defp to_subject(binary) when is_binary(binary), do: binary + defp to_subject(:_), do: :_ + defp to_subject(atom) when is_atom(atom), do: inspect(atom) + defp to_subject(other), do: to_string(other) +end diff --git a/forge/lib/forge/search/store/backends/ets/schemas/v3.ex b/forge/lib/forge/search/store/backends/ets/schemas/v3.ex new file mode 100644 index 00000000..bbd2aa35 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/schemas/v3.ex @@ -0,0 +1,82 @@ +defmodule Forge.Search.Store.Backends.Ets.Schemas.V3 do + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backends.Ets.Schema + + require Entry + use Schema, version: 3 + + defkey(:by_id, [:id, :type, :subtype]) + + defkey(:by_subject, [ + :subject, + :type, + :subtype, + :path + ]) + + defkey(:by_path, [:path]) + defkey(:by_block_id, [:block_id, :path]) + defkey(:structure, [:path]) + + def migrate(entries) do + migrated = + entries + |> Stream.filter(fn + {query_by_subject(), %Entry{}} -> true + _ -> false + end) + |> Stream.map(fn {_, entry} -> entry end) + |> Schema.entries_to_rows(__MODULE__) + + {:ok, migrated} + end + + def to_rows(%Entry{} = entry) when Entry.is_structure(entry) do + structure_key = structure(path: entry.path) + [{structure_key, entry.subject}] + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + block_key = by_block_id(path: entry.path, block_id: entry.block_id) + + [{id_key, entry}, {subject_key, id_key}, {path_key, id_key}, {block_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + if Features.can_use_compressed_ets_table?() do + [:named_table, :ordered_set, :compressed] + else + [:named_table, :ordered_set] + end + end + + def to_subject(charlist) when is_list(charlist), do: charlist + def to_subject(:_), do: :_ + def to_subject(atom) when is_atom(atom), do: atom |> inspect() |> to_charlist() + def to_subject(other), do: to_charlist(other) +end diff --git a/forge/lib/forge/search/store/backends/ets/state.ex b/forge/lib/forge/search/store/backends/ets/state.ex new file mode 100644 index 00000000..56816a37 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/state.ex @@ -0,0 +1,297 @@ +defmodule Forge.Search.Store.Backends.Ets.State do + @moduledoc """ + An ETS based search backend + + This backend uses an ETS table to store its data using a schema defined in the schemas submodule. + + """ + alias Forge.Project + alias Forge.Search.Indexer.Entry + alias Forge.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schemas + alias Forge.Search.Store.Backends.Ets.Wal + + @schema_order [ + Schemas.LegacyV0, + Schemas.V1, + Schemas.V2, + Schemas.V3 + ] + + import Wal, only: :macros + import Entry, only: :macros + + import Schemas.V3, + only: [ + by_block_id: 1, + query_by_id: 1, + query_by_path: 1, + query_structure: 1, + query_by_subject: 1, + structure: 1, + to_subject: 1 + ] + + defstruct [:project, :table_name, :leader?, :leader_pid, :wal_state] + + def new_leader(%Project{} = project) do + %__MODULE__{project: project, leader?: true, leader_pid: self()} + end + + def new_follower(%Project{} = project, leader_pid) do + %__MODULE__{project: project, leader?: false, leader_pid: leader_pid} + end + + def prepare(%__MODULE__{leader?: true} = state) do + {:ok, wal, table_name, result} = Schema.load(state.project, @schema_order) + + {{:ok, result}, %__MODULE__{state | table_name: table_name, wal_state: wal}} + end + + def prepare(%__MODULE__{leader?: false}) do + {:error, :not_leader} + end + + def drop(%__MODULE__{leader?: true} = state) do + Wal.truncate(state.wal_state) + :ets.delete_all_objects(state.table_name) + end + + def insert(%__MODULE__{leader?: true} = state, entries) do + rows = Schema.entries_to_rows(entries, current_schema()) + + with_wal state.wal_state do + true = :ets.insert(state.table_name, rows) + end + + :ok + end + + def reduce(%__MODULE__{} = state, acc, reducer_fun) do + ets_reducer = fn + {{:by_id, _, _, _}, entries}, acc when is_list(entries) -> + Enum.reduce(entries, acc, reducer_fun) + + {{:by_id, _, _, _}, %Entry{} = entry}, acc -> + reducer_fun.(entry, acc) + + _, acc -> + acc + end + + :ets.foldl(ets_reducer, acc, state.table_name) + end + + def find_by_subject(%__MODULE__{} = state, subject, type, subtype) do + match_pattern = + query_by_subject( + subject: to_subject(subject), + type: type, + subtype: subtype + ) + + state.table_name + |> :ets.match_object({match_pattern, :_}) + |> Enum.flat_map(fn {_, id_keys} -> + id_keys + end) + |> MapSet.new() + |> Enum.flat_map(&:ets.lookup_element(state.table_name, &1, 2)) + end + + def find_by_prefix(%__MODULE__{} = state, subject, type, subtype) do + match_pattern = + query_by_subject( + subject: to_prefix(subject), + type: type, + subtype: subtype + ) + + state.table_name + |> :ets.select([{{match_pattern, :_}, [], [:"$_"]}]) + |> Stream.flat_map(fn {_, id_keys} -> id_keys end) + |> Stream.uniq() + |> Enum.flat_map(&:ets.lookup_element(state.table_name, &1, 2)) + end + + @dialyzer {:nowarn_function, to_prefix: 1} + + defp to_prefix(prefix) when is_binary(prefix) do + # what we really want to do here is convert the prefix to a improper list + # like this: `'abc' -> [97, 98, 99 | :_]`, it's different from `'abc' ++ [:_]` + # this is the required format for the `:ets.select` function. + {last_char, others} = prefix |> String.to_charlist() |> List.pop_at(-1) + others ++ [last_char | :_] + end + + def siblings(%__MODULE__{} = state, %Entry{} = entry) do + key = by_block_id(block_id: entry.block_id, path: entry.path) + + siblings = + state.table_name + |> :ets.lookup_element(key, 2) + |> Enum.map(&:ets.lookup_element(state.table_name, &1, 2)) + |> List.flatten() + |> Enum.filter(fn sibling -> + case {is_block(entry), is_block(sibling)} do + {same, same} -> true + _ -> false + end + end) + |> Enum.sort_by(& &1.id) + |> Enum.uniq() + + {:ok, siblings} + rescue + ArgumentError -> + :error + end + + def parent(%__MODULE__{} = state, %Entry{} = entry) do + with {:ok, structure} <- structure_for_path(state, entry.path), + {:ok, child_path} <- child_path(structure, entry.block_id) do + child_path = + if is_block(entry) do + # if we're a block, finding the first block will find us, so pop + # our id off the path. + tl(child_path) + else + child_path + end + + find_first_by_block_id(state, child_path) + end + end + + def parent(%__MODULE__{}, :root) do + :error + end + + def find_by_ids(%__MODULE__{} = state, ids, type, subtype) + when is_list(ids) do + for id <- ids, + match_pattern = match_id_key(id, type, subtype), + {_key, entry} <- :ets.match_object(state.table_name, match_pattern) do + entry + end + |> List.flatten() + end + + def replace_all(%__MODULE__{leader?: true} = state, entries) do + rows = Schema.entries_to_rows(entries, current_schema()) + + {:ok, _, result} = + with_wal state.wal_state do + true = :ets.delete_all_objects(state.table_name) + true = :ets.insert(state.table_name, rows) + :ok + end + + # When we replace everything, the old checkpoint is invalidated + # so it makes sense to force a new one. + Wal.checkpoint(state.wal_state) + result + end + + def delete_by_path(%__MODULE__{leader?: true} = state, path) do + ids_to_delete = + state.table_name + |> :ets.match({query_by_path(path: path), :"$0"}) + |> List.flatten() + + with_wal state.wal_state do + :ets.match_delete(state.table_name, {query_by_subject(path: path), :_}) + :ets.match_delete(state.table_name, {query_by_path(path: path), :_}) + :ets.match_delete(state.table_name, {query_structure(path: path), :_}) + end + + Enum.each(ids_to_delete, fn id -> + with_wal state.wal_state do + :ets.delete(state.table_name, id) + end + end) + + {:ok, ids_to_delete} + end + + def destroy_all(%Project{} = project) do + Wal.destroy_all(project) + end + + def destroy(%__MODULE__{leader?: true, wal_state: %Wal{}} = state) do + Wal.destroy(state.wal_state) + end + + def destroy(%__MODULE__{leader?: true}) do + :ok + end + + def terminate(%__MODULE__{wal_state: %Wal{}} = state) do + Wal.close(state.wal_state) + end + + def terminate(%__MODULE__{}) do + :ok + end + + defp child_path(structure, child_id) do + path = + Enum.reduce_while(structure, [], fn + {^child_id, _children}, children -> + {:halt, [child_id | children]} + + {_, children}, path when map_size(children) == 0 -> + {:cont, path} + + {current_id, children}, path -> + case child_path(children, child_id) do + {:ok, child_path} -> {:halt, [current_id | path] ++ Enum.reverse(child_path)} + :error -> {:cont, path} + end + end) + + case path do + [] -> :error + path -> {:ok, Enum.reverse(path)} + end + end + + defp find_first_by_block_id(%__MODULE__{} = state, block_ids) do + Enum.reduce_while(block_ids, :error, fn block_id, failure -> + case find_entry_by_id(state, block_id) do + {:ok, _} = success -> + {:halt, success} + + _ -> + {:cont, failure} + end + end) + end + + def find_entry_by_id(%__MODULE__{} = state, id) do + case find_by_ids(state, [id], :_, :_) do + [entry] -> {:ok, entry} + _ -> :error + end + end + + def structure_for_path(%__MODULE__{} = state, path) do + key = structure(path: path) + + case :ets.lookup_element(state.table_name, key, 2) do + [structure] -> {:ok, structure} + _ -> :error + end + rescue + ArgumentError -> + :error + end + + defp match_id_key(id, type, subtype) do + {query_by_id(id: id, type: type, subtype: subtype), :_} + end + + defp current_schema do + List.last(@schema_order) + end +end diff --git a/forge/lib/forge/search/store/backends/ets/wal.ex b/forge/lib/forge/search/store/backends/ets/wal.ex new file mode 100644 index 00000000..76049662 --- /dev/null +++ b/forge/lib/forge/search/store/backends/ets/wal.ex @@ -0,0 +1,423 @@ +defmodule Forge.Search.Store.Backends.Ets.Wal do + @moduledoc """ + A (hopefully) simple write-ahead log + """ + alias Forge.Identifier + alias Forge.Project + alias Forge.VM.Versions + + import Record + + defrecord :operation, id: nil, function: nil, args: nil + + defstruct [ + :checkpoint_version, + :ets_table, + :max_wal_operations, + :project, + :schema_version, + :update_log, + :update_log_name + ] + + @write_functions [ + :delete, + :delete_all_objects, + :delete_object, + :insert, + :insert_new, + :match_delete, + :select_delete, + :select_replace, + :update_counter, + :update_element + ] + + @no_checkpoint_id 0 + @chunk_size 10_000 + @checkpoint_int_length 20 + @default_max_operations 50_000 + + defmacro with_wal(wal_state, do: block) do + {_, write_calls} = + Macro.prewalk(block, [], fn ast, acc -> + {ast, collect_ets_writes(ast, acc)} + end) + + operations = + write_calls + |> Enum.reverse() + |> Enum.map(&to_operation/1) + + quote do + case unquote(__MODULE__).append(unquote(wal_state), unquote(operations)) do + {:ok, wal_state} -> + result = unquote(block) + {:ok, wal_state, result} + + error -> + error + end + end + end + + def load(%Project{} = project, schema_version, ets_table, options \\ []) do + max_wal_operations = Keyword.get(options, :max_wal_operations, @default_max_operations) + + wal = %__MODULE__{ + ets_table: ets_table, + max_wal_operations: max_wal_operations, + project: project, + schema_version: to_string(schema_version) + } + + ensure_wal_directory_exists(wal) + + with {:ok, checkpoint_id} <- load_latest_checkpoint(wal), + {:ok, new_wal} <- open_update_wal(wal, checkpoint_id), + :ok <- apply_updates(new_wal) do + {:ok, new_wal} + end + end + + def exists?(%__MODULE__{} = wal) do + exists?(wal.project, wal.schema_version) + end + + def exists?(%Project{} = project, schema_vesion) do + case File.ls(wal_directory(project, schema_vesion)) do + {:ok, [_]} -> true + {:ok, [_ | _]} -> true + _ -> false + end + end + + def append(%__MODULE__{} = wal, operations) do + case :disk_log.log_terms(wal.update_log, operations) do + :ok -> + maybe_checkpoint(wal) + + error -> + error + end + end + + def close(%__MODULE__{} = wal) do + case wal.update_log do + nil -> + :ok + + log -> + :disk_log.sync(log) + :disk_log.close(log) + end + end + + def truncate(%__MODULE__{} = wal) do + :disk_log.truncate(wal.update_log) + end + + def destroy(%__MODULE__{} = wal) do + close(wal) + destroy(wal.project, wal.schema_version) + end + + def destroy(%Project{} = project, schema_version) do + project + |> wal_directory(schema_version) + |> File.rm_rf!() + end + + def destroy_all(%Project{} = project) do + project + |> root_path() + |> File.rm_rf!() + end + + def checkpoint(%__MODULE__{} = wal) do + case :ets.info(wal.ets_table) do + :undefined -> + {:error, :no_table} + + _ -> + do_checkpoint(wal) + end + end + + def size(%__MODULE__{update_log: nil}) do + {:error, :not_loaded} + end + + def size(%__MODULE__{update_log: update_log}) do + with info when is_list(info) <- :disk_log.info(update_log), + {:ok, size} <- Keyword.fetch(info, :items) do + {:ok, size} + else + _ -> + {:error, :not_loaded} + end + end + + def root_path(%Project{} = project) do + Project.workspace_path(project, ["indexes", "ets"]) + end + + # Private + + defp collect_ets_writes({{:., _, [:ets, function_name]}, _, args}, acc) + when function_name in @write_functions do + [{:ets, function_name, args} | acc] + end + + defp collect_ets_writes(_, acc), do: acc + + defp to_operation({:ets, call_name, args}) do + quote do + operation(id: Identifier.next_global!(), function: unquote(call_name), args: unquote(args)) + end + end + + defp ensure_wal_directory_exists(%__MODULE__{} = wal) do + wal |> wal_directory() |> File.mkdir_p!() + end + + defp wal_directory(%__MODULE__{} = wal) do + wal_directory(wal.project, wal.schema_version) + end + + defp wal_directory(%Project{} = project, schema_version) do + versions = Versions.current() + Path.join([root_path(project), versions.erlang, versions.elixir, to_string(schema_version)]) + end + + defp open_update_wal(%__MODULE__{} = wal, checkpoint_version) do + wal_path = update_wal_path(wal) + wal_name = update_wal_name(wal) + + case :disk_log.open(name: wal_name, file: String.to_charlist(wal_path)) do + {:ok, log} -> + new_wal = %__MODULE__{ + wal + | update_log: log, + update_log_name: wal_name, + checkpoint_version: checkpoint_version + } + + {:ok, new_wal} + + {:repaired, log, {:recovered, _}, _bad} -> + new_wal = %__MODULE__{ + wal + | update_log: log, + update_log_name: wal_name, + checkpoint_version: checkpoint_version + } + + {:ok, new_wal} + + error -> + error + end + end + + defp update_wal_name(%__MODULE__{} = wal) do + :"updates_for_#{Project.name(wal.project)}_v#{wal.schema_version}" + end + + # Updates + defp apply_updates(%__MODULE__{} = wal) do + stream_updates(wal, wal.update_log, :start) + end + + defp stream_updates(%__MODULE__{} = wal, log, continuation) do + case :disk_log.chunk(log, continuation, @chunk_size) do + {continuation, items} when is_list(items) -> + apply_relevant_items(wal, items) + stream_updates(wal, log, continuation) + + {continuation, items, _bad_bytes} -> + apply_relevant_items(wal, items) + stream_updates(wal, log, continuation) + + :eof -> + :ok + + {:error, _} = error -> + error + end + end + + defp apply_relevant_items(%__MODULE__{} = wal, items) do + checkpoint_version = wal.checkpoint_version + + items + |> Stream.filter(fn operation(id: id) -> id >= checkpoint_version end) + |> Enum.each(fn operation(function: function, args: args) -> + apply(:ets, function, args) + end) + end + + defp get_wal_operations(%__MODULE__{} = wal) do + stats = :disk_log.info(wal.update_log) + Keyword.get(stats, :items, 0) + end + + # Checkpoints + defp needs_checkpoint?(%__MODULE__{} = wal) do + get_wal_operations(wal) >= wal.max_wal_operations + end + + defp maybe_checkpoint(%__MODULE__{} = wal) do + with true <- needs_checkpoint?(wal), + {:ok, new_wal} <- checkpoint(wal) do + {:ok, new_wal} + else + _ -> + {:ok, wal} + end + end + + defp do_checkpoint(%__MODULE__{} = wal) do + checkpoint_version = Identifier.next_global!() + checkpoint_file_name = checkpoint_file_name(checkpoint_version) + + log_path = wal |> wal_directory() |> Path.join(checkpoint_file_name) + log_name = checkpoint_log_name(wal.project) + + with {:ok, log} <- :disk_log.open(name: log_name, file: String.to_charlist(log_path)), + :ok <- checkpoint_ets_table(wal, log), + :ok <- :disk_log.close(log), + :ok <- :disk_log.truncate(wal.update_log) do + new_wal = %__MODULE__{wal | checkpoint_version: checkpoint_version} + delete_old_checkpoints(new_wal) + {:ok, new_wal} + else + error -> + # Checkpoint loading failed. Give up and start over + delete_old_checkpoints(wal) + error + end + end + + defp checkpoint_ets_table(%__MODULE__{} = wal, log) do + log_chunks = fn + item, {@chunk_size, items} -> + :disk_log.log_terms(log, Enum.reverse(items)) + {1, [item]} + + item, {count, items} -> + {count + 1, [item | items]} + end + + {_count, items} = :ets.foldl(log_chunks, {0, []}, wal.ets_table) + :disk_log.log_terms(log, Enum.reverse(items)) + end + + defp load_latest_checkpoint(%__MODULE__{} = wal) do + with {:ok, checkpoint_file} <- find_latest_checkpoint(wal), + {:ok, checkpoint_version} <- extract_checkpoint_version(checkpoint_file), + :ok <- load_checkpoint(wal, checkpoint_file) do + {:ok, checkpoint_version} + else + _ -> + # There's no checkpoint, or our checkpoint is invalid. Start from scratch. + {:ok, @no_checkpoint_id} + end + end + + defp load_checkpoint(%__MODULE__{} = wal, checkpoint_file) do + log_name = checkpoint_log_name(wal.project) + + case :disk_log.open(name: log_name, file: String.to_charlist(checkpoint_file)) do + {:ok, log} -> + stream_checkpoint(wal, log, :start) + + {:repaired, log, _recovered, _bad_bytes} -> + stream_checkpoint(wal, log, :start) + + error -> + error + end + end + + defp delete_old_checkpoints(%__MODULE__{} = wal) do + current_checkpoint_file_name = checkpoint_file_name(wal.checkpoint_version) + + [wal_directory(wal), "*.checkpoint"] + |> Path.join() + |> Path.wildcard() + |> Enum.each(fn checkpoint -> + if Path.basename(checkpoint) != current_checkpoint_file_name do + File.rm(checkpoint) + end + end) + end + + defp checkpoint_file_name(checkpoint_id) when is_integer(checkpoint_id) do + checkpoint_id + |> Integer.to_string(10) + |> checkpoint_file_name() + end + + defp checkpoint_file_name(checkpoint_id) when is_binary(checkpoint_id) do + String.pad_leading(checkpoint_id, @checkpoint_int_length, "0") <> ".checkpoint" + end + + defp checkpoint_log_name(%Project{} = project) do + :"checkpoint_log_#{Project.name(project)}" + end + + defp stream_checkpoint(%__MODULE__{} = wal, log, continuation) do + case :disk_log.chunk(log, continuation, @chunk_size) do + {continuation, items} when is_list(items) -> + :ets.insert(wal.ets_table, items) + stream_checkpoint(wal, log, continuation) + + {continuation, items, _bad_bytes} -> + :ets.insert(wal.ets_table, items) + stream_checkpoint(wal, log, continuation) + + :eof -> + :disk_log.close(log) + :ok + + {:error, _} = error -> + :disk_log.close(log) + error + end + end + + defp find_latest_checkpoint(%__MODULE__{} = wal) do + checkpoints = + [wal_directory(wal), "*.checkpoint"] + |> Path.join() + |> Path.wildcard() + |> Enum.sort(:desc) + + case checkpoints do + [checkpoint | _] -> + {:ok, checkpoint} + + _ -> + {:error, :no_checkpoint} + end + end + + defp extract_checkpoint_version(checkpoint_path) do + file_name = Path.basename(checkpoint_path) + + with [id_string, _] <- String.split(file_name, "."), + {id, ""} <- Integer.parse(id_string, 10) do + {:ok, id} + else + _ -> + :error + end + end + + defp update_wal_path(%__MODULE__{} = wal) do + wal + |> wal_directory() + |> Path.join("updates.wal") + end +end diff --git a/forge/lib/forge/search/store/state.ex b/forge/lib/forge/search/store/state.ex new file mode 100644 index 00000000..3539a2e4 --- /dev/null +++ b/forge/lib/forge/search/store/state.ex @@ -0,0 +1,260 @@ +defmodule Forge.Search.Store.State do + alias Forge.Project + alias Forge.Api.Messages + alias Forge.Dispatch + alias Forge.Search.Fuzzy + alias Forge.Search.Indexer.Entry + + require Logger + import Messages + + defstruct [ + :project, + :backend, + :create_index, + :update_index, + :loaded?, + :fuzzy, + :async_load_ref, + :update_buffer + ] + + def new(%Project{} = project, create_index, update_index, backend) do + %__MODULE__{ + backend: backend, + create_index: create_index, + project: project, + loaded?: false, + update_index: update_index, + update_buffer: %{}, + fuzzy: Fuzzy.from_entries([]) + } + end + + def drop(%__MODULE__{} = state) do + state.backend.drop() + end + + def destroy(%__MODULE__{} = state) do + state.backend.destroy(state) + end + + @doc """ + Asynchronously loads the search state. + + This function returns prior to creating or refreshing the index, which + occurs in a separate process. The caller should listen for a message + of the shape `{ref, result}`, where `ref` matches the state's + `:async_load_ref`. Once received, that result should be passed to + `async_load_complete/2`. + """ + def async_load(%__MODULE__{loaded?: false, async_load_ref: nil} = state) do + {:ok, backend_result} = state.backend.new(state.project) + prepare_backend_async(state, backend_result) + end + + def async_load(%__MODULE__{} = state) do + {:ok, state} + end + + def async_load_complete(%__MODULE__{} = state, result) do + new_state = %__MODULE__{state | loaded?: true, async_load_ref: nil} + + response = + case result do + {:create_index, result} -> + create_index_complete(new_state, result) + + {:update_index, result} -> + update_index_complete(new_state, result) + + :initialize_fuzzy -> + initialize_fuzzy(new_state) + end + + Dispatch.broadcast(project_index_ready(project: state.project)) + response + end + + def replace(%__MODULE__{} = state, entries) do + with :ok <- state.backend.replace_all(entries), + :ok <- maybe_sync(state) do + {:ok, %__MODULE__{state | fuzzy: Fuzzy.from_backend(state.backend)}} + end + end + + def exact(%__MODULE__{} = state, subject, constraints) do + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_subject(subject, type, subtype) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + + def prefix(%__MODULE__{} = state, prefix, constraints) do + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_prefix(prefix, type, subtype) do + l when is_list(l) -> + {:ok, l} + + error -> + error + end + end + + def fuzzy(%__MODULE__{} = state, subject, constraints) do + case Fuzzy.match(state.fuzzy, subject) do + [] -> + {:ok, []} + + ids -> + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_ids(ids, type, subtype) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + end + + def siblings(%__MODULE__{} = state, entry) do + case state.backend.siblings(entry) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + + def parent(%__MODULE__{} = state, entry) do + case state.backend.parent(entry) do + %Entry{} = entry -> {:ok, entry} + error -> error + end + end + + def buffer_updates(%__MODULE__{} = state, path, entries) do + %__MODULE__{state | update_buffer: Map.put(state.update_buffer, path, entries)} + end + + def drop_buffered_updates(%__MODULE__{} = state) do + %__MODULE__{state | update_buffer: %{}} + end + + def flush_buffered_updates(%__MODULE__{update_buffer: buffer} = state) + when map_size(buffer) == 0 do + maybe_sync(state) + {:ok, state} + end + + def flush_buffered_updates(%__MODULE__{} = state) do + result = + Enum.reduce_while(state.update_buffer, state, fn {path, entries}, state -> + case update_nosync(state, path, entries) do + {:ok, new_state} -> + {:cont, new_state} + + error -> + {:halt, error} + end + end) + + with %__MODULE__{} = state <- result, + :ok <- maybe_sync(state) do + {:ok, drop_buffered_updates(state)} + end + end + + def update_nosync(%__MODULE__{} = state, path, entries) do + with {:ok, deleted_ids} <- state.backend.delete_by_path(path), + :ok <- state.backend.insert(entries) do + fuzzy = + state.fuzzy + |> Fuzzy.drop_values(deleted_ids) + |> Fuzzy.add(entries) + + {:ok, %__MODULE__{state | fuzzy: fuzzy}} + end + end + + require Logger + + defp prepare_backend_async(%__MODULE__{async_load_ref: nil} = state, backend_result) do + task = + Task.async(fn -> + case state.backend.prepare(backend_result) do + {:ok, :empty} -> + Logger.info("backend reports empty") + {:create_index, state.create_index.(state.project)} + + {:ok, :stale} -> + Logger.info("backend reports stale") + {:update_index, state.update_index.(state.project, state.backend)} + + {:error, :not_leader} -> + :initialize_fuzzy + + error -> + Logger.error("Could not initialize index due to #{inspect(error)}") + error + end + end) + + %__MODULE__{state | async_load_ref: task.ref} + end + + defp create_index_complete(%__MODULE__{} = state, {:ok, entries}) do + case replace(state, entries) do + {:ok, state} -> + state + + {:error, _} -> + Logger.warning("Could not replace entries") + state + end + end + + defp create_index_complete(%__MODULE__{} = state, {:error, _} = error) do + Logger.warning("Could not create index, got: #{inspect(error)}") + state + end + + defp update_index_complete(%__MODULE__{} = state, {:ok, updated_entries, deleted_paths}) do + starting_state = initialize_fuzzy(%__MODULE__{state | loaded?: true}) + + new_state = + updated_entries + |> Enum.group_by(& &1.path) + |> Enum.reduce(starting_state, fn {path, entry_list}, state -> + {:ok, new_state} = update_nosync(state, path, entry_list) + new_state + end) + + Enum.reduce(deleted_paths, new_state, fn path, state -> + {:ok, new_state} = update_nosync(state, path, []) + new_state + end) + end + + defp update_index_complete(%__MODULE__{} = state, {:error, _} = error) do + Logger.warning("Could not update index, got: #{inspect(error)}") + state + end + + defp maybe_sync(%__MODULE__{} = state) do + if function_exported?(state.backend, :sync, 1) do + state.backend.sync(state.project) + else + :ok + end + end + + defp initialize_fuzzy(%__MODULE__{} = state) do + fuzzy = Fuzzy.from_backend(state.backend) + + %__MODULE__{state | fuzzy: fuzzy} + end +end diff --git a/forge/lib/forge/search/subject.ex b/forge/lib/forge/search/subject.ex new file mode 100644 index 00000000..c278fc1e --- /dev/null +++ b/forge/lib/forge/search/subject.ex @@ -0,0 +1,18 @@ +defmodule Forge.Search.Subject do + @moduledoc """ + Functions for converting to a search entry's subject field + """ + alias Forge.Formats + + def module(module) do + module + end + + def module_attribute(_module, attribute_name) do + "@#{attribute_name}" + end + + def mfa(module, function, arity) do + Formats.mfa(module, function, arity) + end +end diff --git a/forge/lib/forge/struct_access.ex b/forge/lib/forge/struct_access.ex new file mode 100644 index 00000000..afb8919e --- /dev/null +++ b/forge/lib/forge/struct_access.ex @@ -0,0 +1,43 @@ +defmodule Forge.StructAccess do + @moduledoc """ + Allows structs to easily adopt the `Access` behaviour. + """ + defmacro __using__(_) do + quote location: :keep do + @doc false + def fetch(struct, key) when is_map_key(struct, key) do + {:ok, Map.get(struct, key)} + end + + @doc false + def fetch(_, _) do + :error + end + + @doc false + def get_and_update(struct, key, function) when is_map_key(struct, key) do + old_value = Map.get(struct, key) + + case function.(old_value) do + {current_value, updated_value} -> {current_value, Map.put(struct, key, updated_value)} + :pop -> {old_value, Map.put(struct, key, nil)} + end + end + + @doc false + def get_and_update(struct, key, function) do + {{:error, {:nonexistent_key, key}}, struct} + end + + @doc false + def pop(struct, key) when is_map_key(struct, key) do + {Map.get(struct, key), struct} + end + + @doc false + def pop(struct, _key) do + {nil, struct} + end + end + end +end diff --git a/forge/lib/forge/text.ex b/forge/lib/forge/text.ex new file mode 100644 index 00000000..ce115dec --- /dev/null +++ b/forge/lib/forge/text.ex @@ -0,0 +1,8 @@ +defmodule Forge.Text do + def count_leading_spaces(str), do: count_leading_spaces(str, 0) + + def count_leading_spaces(<>, count) when c in [?\s, ?\t], + do: count_leading_spaces(rest, count + 1) + + def count_leading_spaces(_, count), do: count +end diff --git a/forge/lib/forge/vm/versions.ex b/forge/lib/forge/vm/versions.ex new file mode 100644 index 00000000..9e33755d --- /dev/null +++ b/forge/lib/forge/vm/versions.ex @@ -0,0 +1,228 @@ +defmodule Forge.VM.Versions do + @moduledoc """ + Reads and writes version tags for elixir and erlang + + When compiling, it is important to node which version of the VM and elixir runtime + were used to build the beam files, as beam files compiled on a newer version of the + VM cannot be used on older versions. + + This module allows a directory to be tagged with the versions of elixir and erlang + used as compilation artifacts, and also allows the user to ask if a certain version + is compatible with the currently running VM. + """ + + @type version_string :: String.t() + + @type t :: %{elixir: version_string(), erlang: version_string()} + @type versioned_t :: %{elixir: Version.t(), erlang: Version.t()} + + @doc """ + Returns the versions of elixir and erlang in the currently running VM + """ + @spec current() :: t + def current do + %{ + elixir: elixir_version(), + erlang: erlang_version() + } + end + + @doc """ + Returns the compiled-in versions of elixir and erlang. + + This function uses the code server to find `.elixir` and `.erlang` files in the code path. + Each of these files represent the version of the runtime the artifact was compiled with. + """ + @spec compiled() :: {:ok, t} | {:error, term()} + def compiled do + with {:ok, elixir_path} <- code_find_file(version_file(:elixir)), + {:ok, erlang_path} <- code_find_file(version_file(:erlang)), + {:ok, elixir_version} <- read_file(elixir_path), + {:ok, erlang_version} <- read_file(erlang_path) do + {:ok, %{elixir: String.trim(elixir_version), erlang: String.trim(erlang_version)}} + end + end + + @doc """ + Converts the values of a version map into `Version` structs + """ + @spec to_versions(t) :: versioned_t() + def to_versions(%{elixir: elixir, erlang: erlang}) do + %{elixir: to_version(elixir), erlang: to_version(erlang)} + end + + @doc """ + Tells whether or not the current version of VM is supported by + Forge's compiled artifacts. + """ + @spec compatible?() :: boolean + @spec compatible?(Path.t()) :: boolean + def compatible? do + case code_find_file(version_file(:erlang)) do + {:ok, path} -> + path + |> Path.dirname() + |> compatible?() + + _ -> + false + end + end + + def compatible?(directory) do + system = current() + + case read(directory) do + {:ok, tagged} -> + system_erlang = to_version(system.erlang) + tagged_erlang = to_version(tagged.erlang) + + tagged_erlang.major <= system_erlang.major + + _ -> + false + end + end + + @doc """ + Returns true if the current directory has version tags for + both elixir and erlang in it. + """ + def tagged?(directory) do + with true <- File.exists?(version_file_path(directory, :elixir)) do + File.exists?(version_file_path(directory, :erlang)) + end + end + + @doc """ + Writes version tags in the given directory, overwriting any that are present + """ + def write(directory) do + write_erlang_version(directory) + write_elixir_version(directory) + end + + @doc """ + Reads all the version tags in the given directory. + This function will fail if one or both tags is missing + """ + def read(directory) do + with {:ok, elixir} <- read_elixir_version(directory), + {:ok, erlang} <- read_erlang_version(directory) do + {:ok, %{elixir: String.trim(elixir), erlang: String.trim(erlang)}} + end + end + + defp write_erlang_version(directory) do + directory + |> version_file_path(:erlang) + |> write_file!(erlang_version()) + end + + defp write_elixir_version(directory) do + directory + |> version_file_path(:elixir) + |> write_file!(elixir_version()) + end + + defp read_erlang_version(directory) do + directory + |> version_file_path(:erlang) + |> read_file() + end + + defp read_elixir_version(directory) do + directory + |> version_file_path(:elixir) + |> read_file() + end + + defp elixir_version do + System.version() + end + + defp erlang_version do + case :persistent_term.get({__MODULE__, :current_erlang}, :not_found) do + :not_found -> + major = :otp_release |> :erlang.system_info() |> List.to_string() + version_file = Path.join([:code.root_dir(), "releases", major, "OTP_VERSION"]) + + erlang_version = + try do + {:ok, contents} = read_file(version_file) + String.split(contents, "\n", trim: true) + else + [full] -> full + _ -> major + catch + :error -> + major + end + + :persistent_term.put({__MODULE__, :current_erlang}, erlang_version) + erlang_version() + + erlang_version -> + erlang_version + end + end + + defp version_file_path(directory, language) do + Path.join(directory, version_file(language)) + end + + defp version_file(language) do + ".#{language}" + end + + defp normalize(erlang_version) do + # Erlang doesn't use versions compabible with semantic versioning, + # this will make it compatible, as whatever the last number represents + # won't introduce vm-level incompatibilities. + + version_components = + erlang_version + |> String.split(".") + |> Enum.take(3) + + normalized = + case version_components do + [major] -> [major, "0", "0"] + [major, minor] -> [major, minor, "0"] + [_, _, _] = version -> version + [major, minor, patch | _] -> [major, minor, patch] + end + + Enum.join(normalized, ".") + end + + defp code_find_file(file_name) when is_binary(file_name) do + file_name + |> String.to_charlist() + |> code_find_file() + end + + defp code_find_file(file_name) when is_list(file_name) do + case :code.where_is_file(file_name) do + :non_existing -> + {:error, {:file_missing, file_name}} + + path -> + {:ok, List.to_string(path)} + end + end + + defp to_version(version) when is_binary(version) do + version |> normalize() |> Version.parse!() + end + + # these functions exist for testing. I was getting process killed with + # patch if we patch the File module directly + defp write_file!(path, contents) do + File.write!(path, contents) + end + + defp read_file(path) do + File.read(path) + end +end diff --git a/forge/lib/future/code.ex b/forge/lib/future/code.ex new file mode 100644 index 00000000..c14ec8a6 --- /dev/null +++ b/forge/lib/future/code.ex @@ -0,0 +1,2095 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/bacea2cef6323d0ede4222f36ddcedd82cb514e4/lib/elixir/lib/code.ex +# I commented print_diagnostic/1, because it is not used in the codebase. +# And I changed string_to_quoted/2 to make it use :future_elixir +defmodule Future.Code do + @moduledoc ~S""" + Utilities for managing code compilation, code evaluation, and code loading. + + This module complements Erlang's [`:code` module](`:code`) + to add behaviour which is specific to Elixir. For functions to + manipulate Elixir's AST (rather than evaluating it), see the + `Macro` module. + + ## Working with files + + This module contains three functions for compiling and evaluating files. + Here is a summary of them and their behaviour: + + * `require_file/2` - compiles a file and tracks its name. It does not + compile the file again if it has been previously required. + + * `compile_file/2` - compiles a file without tracking its name. Compiles the + file multiple times when invoked multiple times. + + * `eval_file/2` - evaluates the file contents without tracking its name. It + returns the result of the last expression in the file, instead of the modules + defined in it. Evaluated files do not trigger the compilation tracers described + in the next section. + + In a nutshell, the first must be used when you want to keep track of the files + handled by the system, to avoid the same file from being compiled multiple + times. This is common in scripts. + + `compile_file/2` must be used when you are interested in the modules defined in a + file, without tracking. `eval_file/2` should be used when you are interested in + the result of evaluating the file rather than the modules it defines. + + The functions above work with Elixir source. If you want to work + with modules compiled to bytecode, which have the `.beam` extension + and are typically found below the _build directory of a Mix project, + see the functions in Erlang's [`:code`](`:code`) module. + + ## Code loading on the Erlang VM + + Erlang has two modes to load code: interactive and embedded. + + By default, the Erlang VM runs in interactive mode, where modules + are loaded as needed. In embedded mode the opposite happens, as all + modules need to be loaded upfront or explicitly. + + You can use `ensure_loaded/1` (as well as `ensure_loaded?/1` and + `ensure_loaded!/1`) to check if a module is loaded before using it and + act. + + ## `ensure_compiled/1` and `ensure_compiled!/1` + + Elixir also includes `ensure_compiled/1` and `ensure_compiled!/1` + functions that are a superset of `ensure_loaded/1`. + + Since Elixir's compilation happens in parallel, in some situations + you may need to use a module that was not yet compiled, therefore + it can't even be loaded. + + When invoked, `ensure_compiled/1` and `ensure_compiled!/1` halt the + compilation of the caller until the module becomes available. Note that + the distinction between `ensure_compiled/1` and `ensure_compiled!/1` + is important: if you are using `ensure_compiled!/1`, you are + indicating to the compiler that you can only continue if said module + is available. + + If you are using `Code.ensure_compiled/1`, you are implying you may + continue without the module and therefore Elixir may return + `{:error, :unavailable}` for cases where the module is not yet available + (but may be available later on). + + For those reasons, developers must typically use `Code.ensure_compiled!/1`. + In particular, do not do this: + + case Code.ensure_compiled(module) do + {:module, _} -> module + {:error, _} -> raise ... + end + + Finally, note you only need `ensure_compiled!/1` to check for modules + being defined within the same project. It does not apply to modules from + dependencies as dependencies are always compiled upfront. + + In most cases, `ensure_loaded/1` is enough. `ensure_compiled!/1` + must be used in rare cases, usually involving macros that need to + invoke a module for callback information. The use of `ensure_compiled/1` + is even less likely. + + ## Compilation tracers + + Elixir supports compilation tracers, which allow modules to observe constructs + handled by the Elixir compiler when compiling files. A tracer is a module + that implements the `trace/2` function. The function receives the event name + as first argument and `Macro.Env` as second and it must return `:ok`. It is + very important for a tracer to do as little work as possible synchronously + and dispatch the bulk of the work to a separate process. **Slow tracers will + slow down compilation**. + + You can configure your list of tracers via `put_compiler_option/2`. The + following events are available to tracers: + + * `:start` - (since v1.11.0) invoked whenever the compiler starts to trace + a new lexical context. A lexical context is started when compiling a new + file or when defining a module within a function. Note evaluated code + does not start a new lexical context (because they don't track unused + aliases, imports, etc) but defining a module inside evaluated code will. + + Note this event may be emitted in parallel, where multiple files/modules + invoke `:start` and run at the same time. The value of the `lexical_tracker` + of the macro environment, albeit opaque, can be used to uniquely identify + the environment. + + * `:stop` - (since v1.11.0) invoked whenever the compiler stops tracing a + new lexical context, such as a new file. + + * `{:import, meta, module, opts}` - traced whenever `module` is imported. + `meta` is the import AST metadata and `opts` are the import options. + + * `{:imported_function, meta, module, name, arity}` and + `{:imported_macro, meta, module, name, arity}` - traced whenever an + imported function or macro is invoked. `meta` is the call AST metadata, + `module` is the module the import is from, followed by the `name` and `arity` + of the imported function/macro. A :remote_function/:remote_macro event + may still be emitted for the imported module/name/arity. + + * `{:alias, meta, alias, as, opts}` - traced whenever `alias` is aliased + to `as`. `meta` is the alias AST metadata and `opts` are the alias options. + + * `{:alias_expansion, meta, as, alias}` traced whenever there is an alias + expansion for a previously defined `alias`, i.e. when the user writes `as` + which is expanded to `alias`. `meta` is the alias expansion AST metadata. + + * `{:alias_reference, meta, module}` - traced whenever there is an alias + in the code, i.e. whenever the user writes `MyModule.Foo.Bar` in the code, + regardless if it was expanded or not. + + * `{:require, meta, module, opts}` - traced whenever `module` is required. + `meta` is the require AST metadata and `opts` are the require options. + If the `meta` option contains the `:from_macro`, then module was called + from within a macro and therefore must be treated as a compile-time dependency. + + * `{:struct_expansion, meta, module, keys}` - traced whenever `module`'s struct + is expanded. `meta` is the struct AST metadata and `keys` are the keys being + used by expansion + + * `{:remote_function, meta, module, name, arity}` and + `{:remote_macro, meta, module, name, arity}` - traced whenever a remote + function or macro is referenced. `meta` is the call AST metadata, `module` + is the invoked module, followed by the `name` and `arity`. + + * `{:local_function, meta, name, arity}` and + `{:local_macro, meta, name, arity}` - traced whenever a local + function or macro is referenced. `meta` is the call AST metadata, followed by + the `name` and `arity`. + + * `{:compile_env, app, path, return}` - traced whenever `Application.compile_env/3` + or `Application.compile_env!/2` are called. `app` is an atom, `path` is a list + of keys to traverse in the application environment and `return` is either + `{:ok, value}` or `:error`. + + * `{:on_module, bytecode, _ignore}` - (since v1.13.0) traced whenever a module + is defined. This is equivalent to the `@after_compile` callback and invoked + after any `@after_compile` in the given module. The third element is currently + `:none` but it may provide more metadata in the future. It is best to ignore + it at the moment. Note that `Module` functions expecting not yet compiled modules + (such as `Module.definitions_in/1`) are still available at the time this event + is emitted. + + The `:tracers` compiler option can be combined with the `:parser_options` + compiler option to enrich the metadata of the traced events above. + + New events may be added at any time in the future, therefore it is advised + for the `trace/2` function to have a "catch-all" clause. + + Below is an example tracer that prints all remote function invocations: + + defmodule MyTracer do + def trace({:remote_function, _meta, module, name, arity}, env) do + IO.puts "#{env.file}:#{env.line} #{inspect(module)}.#{name}/#{arity}" + :ok + end + + def trace(_event, _env) do + :ok + end + end + """ + + @typedoc """ + A list with all variables and their values. + + The binding keys are usually atoms, but they may be a tuple for variables + defined in a different context. + """ + @type binding :: [{atom() | tuple(), any}] + + @typedoc """ + Diagnostics returned by the compiler and code evaluation. + """ + @type diagnostic(severity) :: %{ + required(:file) => Path.t(), + required(:severity) => severity, + required(:message) => String.t(), + required(:position) => position, + required(:stacktrace) => Exception.stacktrace(), + optional(any()) => any() + } + + @typedoc "The line. 0 indicates no line." + @type line() :: non_neg_integer() + @type position() :: line() | {pos_integer(), column :: non_neg_integer} + + @boolean_compiler_options [ + :docs, + :debug_info, + :ignore_already_consolidated, + :ignore_module_conflict, + :relative_paths, + :warnings_as_errors + ] + + @list_compiler_options [:no_warn_undefined, :tracers, :parser_options] + + @available_compiler_options @boolean_compiler_options ++ + @list_compiler_options ++ [:on_undefined_variable] + + @doc """ + Lists all required files. + + ## Examples + + Code.require_file("../eex/test/eex_test.exs") + List.first(Code.required_files()) =~ "eex_test.exs" + #=> true + + """ + @doc since: "1.7.0" + @spec required_files() :: [binary] + def required_files do + :elixir_code_server.call(:required) + end + + @deprecated "Use Code.required_files/0 instead" + @doc false + def loaded_files do + required_files() + end + + @doc false + @deprecated "Use Code.Fragment.cursor_context/2 instead" + def cursor_context(code, options \\ []) do + Code.Fragment.cursor_context(code, options) + end + + @doc """ + Removes files from the required files list. + + The modules defined in the file are not removed; + calling this function only removes them from the list, + allowing them to be required again. + + The list of files is managed per Erlang VM node. + + ## Examples + + # Require EEx test code + Code.require_file("../eex/test/eex_test.exs") + + # Now unrequire all files + Code.unrequire_files(Code.required_files()) + + # Note that modules are still available + function_exported?(EExTest.Compiled, :before_compile, 0) + #=> true + + """ + @doc since: "1.7.0" + @spec unrequire_files([binary]) :: :ok + def unrequire_files(files) when is_list(files) do + :elixir_code_server.cast({:unrequire_files, files}) + end + + @deprecated "Use Code.unrequire_files/1 instead" + @doc false + def unload_files(files) do + unrequire_files(files) + end + + @doc """ + Appends a path to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + The path is expanded with `Path.expand/1` before being appended. + It requires the path to exist. Returns a boolean indicating if + the path was successfully added. + + ## Examples + + Code.append_path(".") + #=> true + + Code.append_path("/does_not_exist") + #=> false + + ## Options + + * `:cache` - (since v1.15.0) when true, the code path is cached + the first time it is traversed in order to reduce file system + operations. It requires Erlang/OTP 26, otherwise it is a no-op. + + """ + @spec append_path(Path.t(), cache: boolean()) :: true | false + def append_path(path, opts \\ []) do + apply(:code, :add_pathz, [to_charlist(Path.expand(path)) | cache(opts)]) == true + end + + @doc """ + Prepends a path to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + The path is expanded with `Path.expand/1` before being prepended. + It requires the path to exist. Returns a boolean indicating if + the path was successfully added. + + ## Examples + + Code.prepend_path(".") + #=> true + + Code.prepend_path("/does_not_exist") + #=> false + + ## Options + + * `:cache` - (since v1.15.0) when true, the code path is cached + the first time it is traversed in order to reduce file system + operations. It requires Erlang/OTP 26, otherwise it is a no-op. + + """ + @spec prepend_path(Path.t(), cache: boolean()) :: boolean() + def prepend_path(path, opts \\ []) do + apply(:code, :add_patha, [to_charlist(Path.expand(path)) | cache(opts)]) == true + end + + @doc """ + Prepends a list of `paths` to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + All paths are expanded with `Path.expand/1` before being prepended. + Only existing paths are prepended. This function always returns `:ok`, + regardless of how many paths were prepended. Use `prepend_path/1` + if you need more control. + + ## Examples + + Code.prepend_paths([".", "/does_not_exist"]) + #=> :ok + + ## Options + + * `:cache` - when true, the code path is cached the first time + it is traversed in order to reduce file system operations. + It requires Erlang/OTP 26, otherwise it is a no-op. + """ + @doc since: "1.15.0" + @spec prepend_paths([Path.t()], cache: boolean()) :: :ok + def prepend_paths(paths, opts \\ []) when is_list(paths) do + apply(:code, :add_pathsa, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)]) + end + + @doc """ + Appends a list of `paths` to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + All paths are expanded with `Path.expand/1` before being appended. + Only existing paths are appended. This function always returns `:ok`, + regardless of how many paths were appended. Use `append_path/1` + if you need more control. + + ## Examples + + Code.append_paths([".", "/does_not_exist"]) + #=> :ok + + ## Options + + * `:cache` - when true, the code path is cached the first time + it is traversed in order to reduce file system operations. + It requires Erlang/OTP 26, otherwise it is a no-op. + """ + @doc since: "1.15.0" + @spec append_paths([Path.t()], cache: boolean()) :: :ok + def append_paths(paths, opts \\ []) when is_list(paths) do + apply(:code, :add_pathsz, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)]) + end + + defp cache(opts) do + if function_exported?(:code, :add_path, 2) do + if opts[:cache], do: [:cache], else: [:nocache] + else + [] + end + end + + @doc """ + Deletes a path from the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for finding + module code. The list of files is managed per Erlang VM node. + + The path is expanded with `Path.expand/1` before being deleted. If the + path does not exist, this function returns `false`. + + ## Examples + + Code.prepend_path(".") + Code.delete_path(".") + #=> true + + Code.delete_path("/does_not_exist") + #=> false + + """ + @spec delete_path(Path.t()) :: boolean + def delete_path(path) do + case :code.del_path(to_charlist(Path.expand(path))) do + result when is_boolean(result) -> + result + + {:error, :bad_name} -> + raise ArgumentError, + "invalid argument #{inspect(path)}" + end + end + + @doc """ + Deletes a list of paths from the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for finding + module code. The list of files is managed per Erlang VM node. + + The path is expanded with `Path.expand/1` before being deleted. If the + path does not exist, this function returns `false`. + """ + @doc since: "1.15.0" + @spec delete_paths([Path.t()]) :: :ok + def delete_paths(paths) when is_list(paths) do + for path <- paths do + _ = :code.del_path(to_charlist(Path.expand(path))) + end + + :ok + end + + @doc """ + Evaluates the contents given by `string`. + + The `binding` argument is a list of all variables and their values. + The `opts` argument is a keyword list of environment options. + + **Warning**: `string` can be any Elixir code and will be executed with + the same privileges as the Erlang VM: this means that such code could + compromise the machine (for example by executing system commands). + Don't use `eval_string/3` with untrusted input (such as strings coming + from the network). + + ## Options + + Options can be: + + * `:file` - the file to be considered in the evaluation + + * `:line` - the line on which the script starts + + Additionally, you may also pass an environment as second argument, + so the evaluation happens within that environment. + + Returns a tuple of the form `{value, binding}`, where `value` is the value + returned from evaluating `string`. If an error occurs while evaluating + `string`, an exception will be raised. + + `binding` is a list with all variable names and their values after evaluating + `string`. The binding keys are usually atoms, but they may be a tuple for variables + defined in a different context. The names are in no particular order. + + ## Examples + + iex> {result, binding} = Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + iex> {result, binding} = Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2, c: 3] + + iex> {result, binding} = Code.eval_string("a = a + b", [a: 1, b: 2]) + iex> result + 3 + iex> Enum.sort(binding) + [a: 3, b: 2] + + For convenience, you can pass `__ENV__/0` as the `opts` argument and + all imports, requires and aliases defined in the current environment + will be automatically carried over: + + iex> {result, binding} = Code.eval_string("a + b", [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + """ + @spec eval_string(List.Chars.t(), binding, Macro.Env.t() | keyword) :: {term, binding} + def eval_string(string, binding \\ [], opts \\ []) + + def eval_string(string, binding, %Macro.Env{} = env) do + validated_eval_string(string, binding, env) + end + + def eval_string(string, binding, opts) when is_list(opts) do + validated_eval_string(string, binding, opts) + end + + defp validated_eval_string(string, binding, opts_or_env) do + %{line: line, file: file} = env = env_for_eval(opts_or_env) + forms = :future_elixir.string_to_quoted!(to_charlist(string), line, 1, file, []) + {value, binding, _env} = eval_verify(:eval_forms, [forms, binding, env]) + {value, binding} + end + + defp eval_verify(fun, args) do + Module.ParallelChecker.verify(fn -> + apply(:elixir, fun, args) + end) + end + + @doc """ + Executes the given `fun` and capture all diagnostics. + + Diagnostics are warnings and errors emitted by the compiler + and by functions such as `IO.warn/2`. + + ## Options + + * `:log` - if the diagnostics should be logged as they happen. + Defaults to `false`. + + """ + @doc since: "1.15.0" + @spec with_diagnostics(keyword(), (-> result)) :: {result, [diagnostic(:warning | :error)]} + when result: term() + def with_diagnostics(opts \\ [], fun) do + value = :erlang.get(:elixir_code_diagnostics) + log = Keyword.get(opts, :log, false) + :erlang.put(:elixir_code_diagnostics, {[], log}) + + try do + result = fun.() + {diagnostics, _log?} = :erlang.get(:elixir_code_diagnostics) + {result, Enum.reverse(diagnostics)} + after + if value == :undefined do + :erlang.erase(:elixir_code_diagnostics) + else + :erlang.put(:elixir_code_diagnostics, value) + end + end + end + + # @doc """ + # Prints a diagnostic into the standard error. + # + # A diagnostic is either returned by `Kernel.ParallelCompiler` + # or by `Code.with_diagnostics/2`. + # """ + # @doc since: "1.15.0" + # @spec print_diagnostic(diagnostic(:warning | :error)) :: :ok + # def print_diagnostic(diagnostic) do + # :elixir_errors.print_diagnostic(diagnostic) + # :ok + # end + + @doc ~S""" + Formats the given code `string`. + + The formatter receives a string representing Elixir code and + returns iodata representing the formatted code according to + pre-defined rules. + + ## Options + + * `:file` - the file which contains the string, used for error + reporting + + * `:line` - the line the string starts, used for error reporting + + * `:line_length` - the line length to aim for when formatting + the document. Defaults to 98. Note this value is used as + guideline but there are situations where it is not enforced. + See the "Line length" section below for more information + + * `:locals_without_parens` - a keyword list of name and arity + pairs that should be kept without parens whenever possible. + The arity may be the atom `:*`, which implies all arities of + that name. The formatter already includes a list of functions + and this option augments this list. + + * `:force_do_end_blocks` (since v1.9.0) - when `true`, converts all + inline usages of `do: ...`, `else: ...` and friends into `do`-`end` + blocks. Defaults to `false`. Note that this option is convergent: + once you set it to `true`, **all keywords** will be converted. + If you set it to `false` later on, `do`-`end` blocks won't be + converted back to keywords. + + * `:normalize_bitstring_modifiers` (since v1.14.0) - when `true`, + removes unnecessary parentheses in known bitstring + [modifiers](`<<>>/1`), for example `<>` + becomes `<>`, or adds parentheses for custom + modifiers, where `<>` becomes `<>`. + Defaults to `true`. This option changes the AST. + + * `:normalize_charlists_as_sigils` (since v1.15.0) - when `true`, + formats charlists as [`~c`](`Kernel.sigil_c/2`) sigils, for example + `'foo'` becomes `~c"foo"`. + Defaults to `true`. This option changes the AST. + + ## Design principles + + The formatter was designed under three principles. + + First, the formatter never changes the semantics of the code. + This means the input AST and the output AST are almost always equivalent. + The only cases where the formatter will change the AST is when the input AST + would cause *compiler warnings* and the output AST won't. The cases where + the formatter changes the AST can be disabled through formatting options + if desired. + + The second principle is to provide as little configuration as possible. + This eases the formatter adoption by removing contention points while + making sure a single style is followed consistently by the community as + a whole. + + The formatter does not hard code names. The formatter will not behave + specially because a function is named `defmodule`, `def`, or the like. This + principle mirrors Elixir's goal of being an extensible language where + developers can extend the language with new constructs as if they were + part of the language. When it is absolutely necessary to change behaviour + based on the name, this behaviour should be configurable, such as the + `:locals_without_parens` option. + + ## Running the formatter + + The formatter attempts to fit the most it can on a single line and + introduces line breaks wherever possible when it cannot. + + In some cases, this may lead to undesired formatting. Therefore, **some + code generated by the formatter may not be aesthetically pleasing and + may require explicit intervention from the developer**. That's why we + do not recommend to run the formatter blindly in an existing codebase. + Instead you should format and sanity check each formatted file. + + For example, the formatter may break a long function definition over + multiple clauses: + + def my_function( + %User{name: name, age: age, ...}, + arg1, + arg2 + ) do + ... + end + + While the code above is completely valid, you may prefer to match on + the struct variables inside the function body in order to keep the + definition on a single line: + + def my_function(%User{} = user, arg1, arg2) do + %{name: name, age: age, ...} = user + ... + end + + In some situations, you can use the fact the formatter does not generate + elegant code as a hint for refactoring. Take this code: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + required_permissions == Enum.to_list(MapSet.intersection(MapSet.new(required_permissions), MapSet.new(available_permissions))) + end + + The code above has very long lines and running the formatter is not going + to address this issue. In fact, the formatter may make it more obvious that + you have complex expressions: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + required_permissions == + Enum.to_list( + MapSet.intersection( + MapSet.new(required_permissions), + MapSet.new(available_permissions) + ) + ) + end + + Take such cases as a suggestion that your code should be refactored: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + matching_permissions?(required_permissions, available_permissions) + end + + defp matching_permissions?(required_permissions, available_permissions) do + intersection = + required_permissions + |> MapSet.new() + |> MapSet.intersection(MapSet.new(available_permissions)) + |> Enum.to_list() + + required_permissions == intersection + end + + To sum it up: since the formatter cannot change the semantics of your + code, sometimes it is necessary to tweak or refactor the code to get + optimal formatting. To help better understand how to control the formatter, + we describe in the next sections the cases where the formatter keeps the + user encoding and how to control multiline expressions. + + ## Line length + + Another point about the formatter is that the `:line_length` configuration + is a guideline. In many cases, it is not possible for the formatter to break + your code apart, which means it will go over the line length. For example, + if you have a long string: + + "this is a very long string that will go over the line length" + + The formatter doesn't know how to break it apart without changing the + code underlying syntax representation, so it is up to you to step in: + + "this is a very long string " <> + "that will go over the line length" + + The string concatenation makes the code fit on a single line and also + gives more options to the formatter. + + This may also appear in do/end blocks, where the `do` keyword (or `->`) + may go over the line length because there is no opportunity for the + formatter to introduce a line break in a readable way. For example, + if you do: + + case very_long_expression() do + end + + And only the `do` keyword is above the line length, Elixir **will not** + emit this: + + case very_long_expression() + do + end + + So it prefers to not touch the line at all and leave `do` above the + line limit. + + ## Keeping user's formatting + + The formatter respects the input format in some cases. Those are + listed below: + + * Insignificant digits in numbers are kept as is. The formatter, + however, always inserts underscores for decimal numbers with more + than 5 digits and converts hexadecimal digits to uppercase + + * Strings, charlists, atoms and sigils are kept as is. No character + is automatically escaped or unescaped. The choice of delimiter is + also respected from the input + + * Newlines inside blocks are kept as in the input except for: + 1) expressions that take multiple lines will always have an empty + line before and after and 2) empty lines are always squeezed + together into a single empty line + + * The choice between `:do` keyword and `do`-`end` blocks is left + to the user + + * Lists, tuples, bitstrings, maps, structs and function calls will be + broken into multiple lines if they are followed by a newline in the + opening bracket and preceded by a new line in the closing bracket + + * Newlines before certain operators (such as the pipeline operators) + and before other operators (such as comparison operators) + + The behaviours above are not guaranteed. We may remove or add new + rules in the future. The goal of documenting them is to provide better + understanding on what to expect from the formatter. + + ### Multi-line lists, maps, tuples, and the like + + You can force lists, tuples, bitstrings, maps, structs and function + calls to have one entry per line by adding a newline after the opening + bracket and a new line before the closing bracket lines. For example: + + [ + foo, + bar + ] + + If there are no newlines around the brackets, then the formatter will + try to fit everything on a single line, such that the snippet below + + [foo, + bar] + + will be formatted as + + [foo, bar] + + You can also force function calls and keywords to be rendered on multiple + lines by having each entry on its own line: + + defstruct name: nil, + age: 0 + + The code above will be kept with one keyword entry per line by the + formatter. To avoid that, just squash everything into a single line. + + ### Parens and no parens in function calls + + Elixir has two syntaxes for function calls. With parens and no parens. + By default, Elixir will add parens to all calls except for: + + 1. calls that have `do`-`end` blocks + 2. local calls without parens where the name and arity of the local + call is also listed under `:locals_without_parens` (except for + calls with arity 0, where the compiler always require parens) + + The choice of parens and no parens also affects indentation. When a + function call with parens doesn't fit on the same line, the formatter + introduces a newline around parens and indents the arguments with two + spaces: + + some_call( + arg1, + arg2, + arg3 + ) + + On the other hand, function calls without parens are always indented + by the function call length itself, like this: + + some_call arg1, + arg2, + arg3 + + If the last argument is a data structure, such as maps and lists, and + the beginning of the data structure fits on the same line as the function + call, then no indentation happens, this allows code like this: + + Enum.reduce(some_collection, initial_value, fn element, acc -> + # code + end) + + some_function_without_parens %{ + foo: :bar, + baz: :bat + } + + ## Code comments + + The formatter also handles code comments in a way to guarantee a space + is always added between the beginning of the comment (#) and the next + character. + + The formatter also extracts all trailing comments to their previous line. + For example, the code below + + hello #world + + will be rewritten to + + # world + hello + + Because code comments are handled apart from the code representation (AST), + there are some situations where code comments are seen as ambiguous by the + code formatter. For example, the comment in the anonymous function below + + fn + arg1 -> + body1 + # comment + + arg2 -> + body2 + end + + and in this one + + fn + arg1 -> + body1 + + # comment + arg2 -> + body2 + end + + are considered equivalent (the nesting is discarded alongside most of + user formatting). In such cases, the code formatter will always format to + the latter. + + ## Newlines + + The formatter converts all newlines in code from `\r\n` to `\n`. + """ + @doc since: "1.6.0" + @spec format_string!(binary, keyword) :: iodata + def format_string!(string, opts \\ []) when is_binary(string) and is_list(opts) do + line_length = Keyword.get(opts, :line_length, 98) + + to_quoted_opts = + [ + unescape: false, + warn_on_unnecessary_quotes: false, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + warnings: false + ] ++ opts + + {forms, comments} = string_to_quoted_with_comments!(string, to_quoted_opts) + to_algebra_opts = [comments: comments] ++ opts + doc = Code.Formatter.to_algebra(forms, to_algebra_opts) + Inspect.Algebra.format(doc, line_length) + end + + @doc """ + Formats a file. + + See `format_string!/2` for more information on code formatting and + available options. + """ + @doc since: "1.6.0" + @spec format_file!(binary, keyword) :: iodata + def format_file!(file, opts \\ []) when is_binary(file) and is_list(opts) do + string = File.read!(file) + formatted = format_string!(string, [file: file, line: 1] ++ opts) + [formatted, ?\n] + end + + @doc """ + Evaluates the quoted contents. + + **Warning**: Calling this function inside a macro is considered bad + practice as it will attempt to evaluate runtime values at compile time. + Macro arguments are typically transformed by unquoting them into the + returned quoted expressions (instead of evaluated). + + See `eval_string/3` for a description of `binding` and `opts`. + + ## Examples + + iex> contents = quote(do: var!(a) + var!(b)) + iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + For convenience, you can pass `__ENV__/0` as the `opts` argument and + all options will be automatically extracted from the current environment: + + iex> contents = quote(do: var!(a) + var!(b)) + iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + """ + @spec eval_quoted(Macro.t(), binding, Macro.Env.t() | keyword) :: {term, binding} + def eval_quoted(quoted, binding \\ [], env_or_opts \\ []) do + {value, binding, _env} = + eval_verify(:eval_quoted, [quoted, binding, env_for_eval(env_or_opts)]) + + {value, binding} + end + + @doc """ + Returns an environment for evaluation. + + It accepts either a `Macro.Env`, that is then pruned and prepared, + or a list of options. It returns an environment that is ready for + evaluation. + + Most functions in this module will automatically prepare the given + environment for evaluation, so you don't need to explicitly call + this function, with the exception of `eval_quoted_with_env/3`, + which was designed precisely to be called in a loop, to implement + features such as interactive shells or anything else with multiple + evaluations. + + ## Options + + If an env is not given, the options can be: + + * `:file` - the file to be considered in the evaluation + + * `:line` - the line on which the script starts + """ + @doc since: "1.14.0" + def env_for_eval(env_or_opts), do: :elixir.env_for_eval(env_or_opts) + + @doc """ + Evaluates the given `quoted` contents with `binding` and `env`. + + This function is meant to be called in a loop, to implement features + such as interactive shells or anything else with multiple evaluations. + Therefore, the first time you call this function, you must compute + the initial environment with `env_for_eval/1`. The remaining calls + must pass the environment that was returned by this function. + + ## Options + + * `:prune_binding` - (since v1.14.2) prune binding to keep only + variables read or written by the evaluated code. Note that + variables used by modules are always pruned, even if later used + by the modules. You can submit to the `:on_module` tracer event + and access the variables used by the module from its environment. + + """ + @doc since: "1.14.0" + def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env, opts \\ []) + when is_list(binding) do + eval_verify(:eval_quoted, [quoted, binding, env, opts]) + end + + @doc ~S""" + Converts the given string to its quoted form. + + Returns `{:ok, quoted_form}` if it succeeds, + `{:error, {meta, message_info, token}}` otherwise. + + ## Options + + * `:file` - the filename to be reported in case of parsing errors. + Defaults to `"nofile"`. + + * `:line` - the starting line of the string being parsed. + Defaults to 1. + + * `:column` - (since v1.11.0) the starting column of the string being parsed. + Defaults to 1. + + * `:columns` - when `true`, attach a `:column` key to the quoted + metadata. Defaults to `false`. + + * `:unescape` (since v1.10.0) - when `false`, preserves escaped sequences. + For example, `"null byte\\t\\x00"` will be kept as is instead of being + converted to a bitstring literal. Note if you set this option to false, the + resulting AST is no longer valid, but it can be useful to analyze/transform + source code, typically in in combination with `quoted_to_algebra/2`. + Defaults to `true`. + + * `:existing_atoms_only` - when `true`, raises an error + when non-existing atoms are found by the tokenizer. + Defaults to `false`. + + * `:token_metadata` (since v1.10.0) - when `true`, includes token-related + metadata in the expression AST, such as metadata for `do` and `end` + tokens, for closing tokens, end of expressions, as well as delimiters + for sigils. See `t:Macro.metadata/0`. Defaults to `false`. + + * `:literal_encoder` (since v1.10.0) - how to encode literals in the AST. + It must be a function that receives two arguments, the literal and its + metadata, and it must return `{:ok, ast :: Macro.t}` or + `{:error, reason :: binary}`. If you return anything than the literal + itself as the `term`, then the AST is no longer valid. This option + may still useful for textual analysis of the source code. + + * `:static_atoms_encoder` - the static atom encoder function, see + "The `:static_atoms_encoder` function" section below. Note this + option overrides the `:existing_atoms_only` behaviour for static + atoms but `:existing_atoms_only` is still used for dynamic atoms, + such as atoms with interpolations. + + * `:warn_on_unnecessary_quotes` - when `false`, does not warn + when atoms, keywords or calls have unnecessary quotes on + them. Defaults to `true`. + + ## `Macro.to_string/2` + + The opposite of converting a string to its quoted form is + `Macro.to_string/2`, which converts a quoted form to a string/binary + representation. + + ## The `:static_atoms_encoder` function + + When `static_atoms_encoder: &my_encoder/2` is passed as an argument, + `my_encoder/2` is called every time the tokenizer needs to create a + "static" atom. Static atoms are atoms in the AST that function as + aliases, remote calls, local calls, variable names, regular atoms + and keyword lists. + + The encoder function will receive the atom name (as a binary) and a + keyword list with the current file, line and column. It must return + `{:ok, token :: term} | {:error, reason :: binary}`. + + The encoder function is supposed to create an atom from the given + string. To produce a valid AST, it is required to return `{:ok, term}`, + where `term` is an atom. It is possible to return something other than an atom, + however, in that case the AST is no longer "valid" in that it cannot + be used to compile or evaluate Elixir code. A use case for this is + if you want to use the Elixir parser in a user-facing situation, but + you don't want to exhaust the atom table. + + The atom encoder is not called for *all* atoms that are present in + the AST. It won't be invoked for the following atoms: + + * operators (`:+`, `:-`, and so on) + + * syntax keywords (`fn`, `do`, `else`, and so on) + + * atoms containing interpolation (`:"#{1 + 1} is two"`), as these + atoms are constructed at runtime. + + """ + @spec string_to_quoted(List.Chars.t(), keyword) :: + {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}} + def string_to_quoted(string, opts \\ []) when is_list(opts) do + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + case :future_elixir.string_to_tokens(to_charlist(string), line, column, file, opts) do + {:ok, tokens} -> + :future_elixir.tokens_to_quoted(tokens, file, opts) + + {:error, _error_msg} = error -> + error + end + end + + @doc """ + Converts the given string to its quoted form. + + It returns the AST if it succeeds, + raises an exception otherwise. The exception is a `TokenMissingError` + in case a token is missing (usually because the expression is incomplete), + `SyntaxError` otherwise. + + Check `string_to_quoted/2` for options information. + """ + @spec string_to_quoted!(List.Chars.t(), keyword) :: Macro.t() + def string_to_quoted!(string, opts \\ []) when is_list(opts) do + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + :elixir.string_to_quoted!(to_charlist(string), line, column, file, opts) + end + + @doc """ + Converts the given string to its quoted form and a list of comments. + + This function is useful when performing textual changes to the source code, + while preserving information like comments and literals position. + + Returns `{:ok, quoted_form, comments}` if it succeeds, + `{:error, {line, error, token}}` otherwise. + + Comments are maps with the following fields: + + * `:line` - The line number the source code + + * `:text` - The full text of the comment, including the leading `#` + + * `:previous_eol_count` - How many end of lines there are between the comment and the previous AST node or comment + + * `:next_eol_count` - How many end of lines there are between the comment and the next AST node or comment + + Check `string_to_quoted/2` for options information. + + ## Examples + + iex> Code.string_to_quoted_with_comments("\"" + ...> :foo + ...> + ...> # Hello, world! + ...> + ...> + ...> # Some more comments! + ...> "\"") + {:ok, :foo, [ + %{line: 3, column: 1, previous_eol_count: 2, next_eol_count: 3, text: "\# Hello, world!"}, + %{line: 6, column: 1, previous_eol_count: 3, next_eol_count: 1, text: "\# Some more comments!"}, + ]} + + iex> Code.string_to_quoted_with_comments(":foo # :bar") + {:ok, :foo, [ + %{line: 1, column: 6, previous_eol_count: 0, next_eol_count: 0, text: "\# :bar"} + ]} + + """ + @doc since: "1.13.0" + @spec string_to_quoted_with_comments(List.Chars.t(), keyword) :: + {:ok, Macro.t(), list(map())} | {:error, {location :: keyword, term, term}} + def string_to_quoted_with_comments(string, opts \\ []) when is_list(opts) do + charlist = to_charlist(string) + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + Process.put(:code_formatter_comments, []) + opts = [preserve_comments: &preserve_comments/5] ++ opts + + with {:ok, tokens} <- :future_elixir.string_to_tokens(charlist, line, column, file, opts), + {:ok, forms} <- :future_elixir.tokens_to_quoted(tokens, file, opts) do + comments = Enum.reverse(Process.get(:code_formatter_comments)) + {:ok, forms, comments} + end + after + Process.delete(:code_formatter_comments) + end + + @doc """ + Converts the given string to its quoted form and a list of comments. + + Returns the AST and a list of comments if it succeeds, raises an exception + otherwise. The exception is a `TokenMissingError` in case a token is missing + (usually because the expression is incomplete), `SyntaxError` otherwise. + + Check `string_to_quoted/2` for options information. + """ + @doc since: "1.13.0" + @spec string_to_quoted_with_comments!(List.Chars.t(), keyword) :: {Macro.t(), list(map())} + def string_to_quoted_with_comments!(string, opts \\ []) do + charlist = to_charlist(string) + + case string_to_quoted_with_comments(charlist, opts) do + {:ok, forms, comments} -> + {forms, comments} + + {:error, {location, error, token}} -> + :future_elixir_errors.parse_error( + location, + Keyword.get(opts, :file, "nofile"), + error, + token, + {charlist, Keyword.get(opts, :line, 1), Keyword.get(opts, :column, 1)} + ) + end + end + + defp preserve_comments(line, column, tokens, comment, rest) do + comments = Process.get(:code_formatter_comments) + + comment = %{ + line: line, + column: column, + previous_eol_count: previous_eol_count(tokens), + next_eol_count: next_eol_count(rest, 0), + text: List.to_string(comment) + } + + Process.put(:code_formatter_comments, [comment | comments]) + end + + defp next_eol_count([?\s | rest], count), do: next_eol_count(rest, count) + defp next_eol_count([?\t | rest], count), do: next_eol_count(rest, count) + defp next_eol_count([?\n | rest], count), do: next_eol_count(rest, count + 1) + defp next_eol_count([?\r, ?\n | rest], count), do: next_eol_count(rest, count + 1) + defp next_eol_count(_, count), do: count + + defp previous_eol_count([{token, {_, _, count}} | _]) + when token in [:eol, :",", :";"] and count > 0 do + count + end + + defp previous_eol_count([]), do: 1 + defp previous_eol_count(_), do: 0 + + @doc ~S""" + Converts a quoted expression to an algebra document using Elixir's formatter rules. + + The algebra document can be converted into a string by calling: + + doc + |> Inspect.Algebra.format(:infinity) + |> IO.iodata_to_binary() + + For a high-level function that does the same, see `Macro.to_string/1`. + + ## Formatting considerations + + The Elixir AST does not contain metadata for literals like strings, lists, or + tuples with two elements, which means that the produced algebra document will + not respect all of the user preferences and comments may be misplaced. + To get better results, you can use the `:token_metadata`, `:unescape` and + `:literal_encoder` options to `string_to_quoted/2` to provide additional + information to the formatter: + + [ + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + unescape: false + ] + + This will produce an AST that contains information such as `do` blocks start + and end lines or sigil delimiters, and by wrapping literals in blocks they can + now hold metadata like line number, string delimiter and escaped sequences, or + integer formatting (such as `0x2a` instead of `47`). However, **note this AST is + not valid**. If you evaluate it, it won't have the same semantics as the regular + Elixir AST due to the `:unescape` and `:literal_encoder` options. However, + those options are useful if you're doing source code manipulation, where it's + important to preserve user choices and comments placing. + + ## Options + + * `:comments` - the list of comments associated with the quoted expression. + Defaults to `[]`. It is recommended that both `:token_metadata` and + `:literal_encoder` options are given to `string_to_quoted_with_comments/2` + in order to get proper placement for comments + + * `:escape` - when `true`, escaped sequences like `\n` will be escaped into + `\\n`. If the `:unescape` option was set to `false` when using + `string_to_quoted/2`, setting this option to `false` will prevent it from + escaping the sequences twice. Defaults to `true`. + + * `:locals_without_parens` - a keyword list of name and arity + pairs that should be kept without parens whenever possible. + The arity may be the atom `:*`, which implies all arities of + that name. The formatter already includes a list of functions + and this option augments this list. + + * `:syntax_colors` - a keyword list of colors the output is colorized. + See `Inspect.Opts` for more information. + """ + @doc since: "1.13.0" + @spec quoted_to_algebra(Macro.t(), keyword) :: Inspect.Algebra.t() + def quoted_to_algebra(quoted, opts \\ []) do + quoted + |> Code.Normalizer.normalize(opts) + |> Code.Formatter.to_algebra(opts) + end + + @doc """ + Evaluates the given file. + + Accepts `relative_to` as an argument to tell where the file is located. + + While `require_file/2` and `compile_file/2` return the loaded modules and their + bytecode, `eval_file/2` simply evaluates the file contents and returns the + evaluation result and its binding (exactly the same return value as `eval_string/3`). + """ + @spec eval_file(binary, nil | binary) :: {term, binding} + def eval_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + eval_string(charlist, [], file: file, line: 1) + end + + @deprecated "Use Code.require_file/2 or Code.compile_file/2 instead" + @doc false + def load_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + :elixir_code_server.call({:acquire, file}) + + loaded = + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + + :elixir_code_server.cast({:required, file}) + loaded + end + + @doc """ + Requires the given `file`. + + Accepts `relative_to` as an argument to tell where the file is located. + If the file was already required, `require_file/2` doesn't do anything and + returns `nil`. + + Note that if `require_file/2` is invoked by different processes concurrently, + the first process to invoke `require_file/2` acquires a lock and the remaining + ones will block until the file is available. This means that if `require_file/2` + is called more than once with a given file, that file will be compiled only once. + The first process to call `require_file/2` will get the list of loaded modules, + others will get `nil`. The list of required files is managed per Erlang VM node. + + See `compile_file/2` if you would like to compile a file without tracking its + filenames. Finally, if you would like to get the result of evaluating a file rather + than the modules defined in it, see `eval_file/2`. + + ## Examples + + If the file has not been required, it returns the list of modules: + + modules = Code.require_file("eex_test.exs", "../eex/test") + List.first(modules) + #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>} + + If the file has been required, it returns `nil`: + + Code.require_file("eex_test.exs", "../eex/test") + #=> nil + + """ + @spec require_file(binary, nil | binary) :: [{module, binary}] | nil + def require_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + + case :elixir_code_server.call({:acquire, file}) do + :required -> + nil + + :proceed -> + loaded = + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + + :elixir_code_server.cast({:required, file}) + loaded + end + end + + @doc """ + Gets all compilation options from the code server. + + To get individual options, see `get_compiler_option/1`. + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.compiler_options() + #=> %{debug_info: true, docs: true, ...} + + """ + @spec compiler_options :: map + def compiler_options do + for key <- @available_compiler_options, into: %{} do + {key, :elixir_config.get(key)} + end + end + + @doc """ + Stores all given compilation options. + + Changing the compilation options affect all processes + running in a given Erlang VM node. To store individual + options and for a description of all options, see + `put_compiler_option/2`. + + Returns a map with previous values. + + ## Examples + + Code.compiler_options(warnings_as_errors: true) + #=> %{warnings_as_errors: false} + + """ + @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term} + def compiler_options(opts) do + for {key, value} <- opts, into: %{} do + previous = get_compiler_option(key) + put_compiler_option(key, value) + {key, previous} + end + end + + @doc """ + Returns the value of a given compiler option. + + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.get_compiler_option(:debug_info) + #=> true + + """ + @doc since: "1.10.0" + @spec get_compiler_option(atom) :: term + def get_compiler_option(key) when key in @available_compiler_options do + :elixir_config.get(key) + end + + @doc """ + Returns a list with all available compiler options. + + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.available_compiler_options() + #=> [:docs, :debug_info, ...] + + """ + @spec available_compiler_options() :: [atom] + def available_compiler_options do + @available_compiler_options + end + + @doc """ + Stores a compilation option. + + Changing the compilation options affect all processes running in a + given Erlang VM node. + + Available options are: + + * `:docs` - when `true`, retains documentation in the compiled module. + Defaults to `true`. + + * `:debug_info` - when `true`, retains debug information in the compiled + module. Defaults to `true`. + This enables static analysis tools as it allows developers to + partially reconstruct the original source code. Therefore, disabling + `:debug_info` is not recommended as it removes the ability of the + Elixir compiler and other tools to provide feedback. If you want to + remove the `:debug_info` while deploying, tools like `mix release` + already do such by default. + Additionally, `mix test` disables it via the `:test_elixirc_options` + project configuration option. + This option can also be overridden per module using the `@compile` directive. + + * `:ignore_already_consolidated` (since v1.10.0) - when `true`, does not warn + when a protocol has already been consolidated and a new implementation is added. + Defaults to `false`. + + * `:ignore_module_conflict` - when `true`, does not warn when a module has + already been defined. Defaults to `false`. + + * `:relative_paths` - when `true`, uses relative paths in quoted nodes, + warnings, and errors generated by the compiler. Note disabling this option + won't affect runtime warnings and errors. Defaults to `true`. + + * `:warnings_as_errors` - causes compilation to fail when warnings are + generated. Defaults to `false`. + + * `:no_warn_undefined` (since v1.10.0) - list of modules and `{Mod, fun, arity}` + tuples that will not emit warnings that the module or function does not exist + at compilation time. Pass atom `:all` to skip warning for all undefined + functions. This can be useful when doing dynamic compilation. Defaults to `[]`. + + * `:tracers` (since v1.10.0) - a list of tracers (modules) to be used during + compilation. See the module docs for more information. Defaults to `[]`. + + * `:parser_options` (since v1.10.0) - a keyword list of options to be given + to the parser when compiling files. It accepts the same options as + `string_to_quoted/2` (except by the options that change the AST itself). + This can be used in combination with the tracer to retrieve localized + information about events happening during compilation. Defaults to `[]`. + This option only affects code compilation functions, such as `compile_string/2` + and `compile_file/2` but not `string_to_quoted/2` and friends, as the + latter is used for other purposes beyond compilation. + + * `:on_undefined_variable` (since v1.15.0) - either `:raise` or `:warn`. + When `:raise` (the default), undefined variables will trigger a compilation + error. You may be set it to `:warn` if you want undefined variables to + emit a warning and expand as to a local call to the zero-arity function + of the same name (for example, `node` would be expanded as `node()`). + This `:warn` behaviour only exists for compatibility reasons when working + with old dependencies. + + It always returns `:ok`. Raises an error for invalid options. + + ## Examples + + Code.put_compiler_option(:debug_info, true) + #=> :ok + + """ + @doc since: "1.10.0" + @spec put_compiler_option(atom, term) :: :ok + def put_compiler_option(key, value) when key in @boolean_compiler_options do + if not is_boolean(value) do + raise "compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}" + end + + :elixir_config.put(key, value) + :ok + end + + def put_compiler_option(:no_warn_undefined, value) do + if value != :all and not is_list(value) do + raise "compiler option :no_warn_undefined should be a list or the atom :all, " <> + "got: #{inspect(value)}" + end + + :elixir_config.put(:no_warn_undefined, value) + :ok + end + + def put_compiler_option(key, value) when key in @list_compiler_options do + if not is_list(value) do + raise "compiler option #{inspect(key)} should be a list, got: #{inspect(value)}" + end + + if key == :parser_options and not Keyword.keyword?(value) do + raise "compiler option #{inspect(key)} should be a keyword list, " <> + "got: #{inspect(value)}" + end + + if key == :tracers and not Enum.all?(value, &is_atom/1) do + raise "compiler option #{inspect(key)} should be a list of modules, " <> + "got: #{inspect(value)}" + end + + :elixir_config.put(key, value) + :ok + end + + # TODO: Make this option have no effect on Elixir v2.0 + def put_compiler_option(:on_undefined_variable, value) when value in [:raise, :warn] do + :elixir_config.put(:on_undefined_variable, value) + :ok + end + + def put_compiler_option(key, _value) do + raise "unknown compiler option: #{inspect(key)}" + end + + @doc """ + Purge compiler modules. + + The compiler utilizes temporary modules to compile code. For example, + `elixir_compiler_1`, `elixir_compiler_2`, and so on. In case the compiled code + stores references to anonymous functions or similar, the Elixir compiler + may be unable to reclaim those modules, keeping an unnecessary amount of + code in memory and eventually leading to modules such as `elixir_compiler_12345`. + + This function purges all modules currently kept by the compiler, allowing + old compiler module names to be reused. If there are any processes running + any code from such modules, they will be terminated too. + + This function is only meant to be called if you have a long running node + that is constantly evaluating code. + + It returns `{:ok, number_of_modules_purged}`. + """ + @doc since: "1.7.0" + @spec purge_compiler_modules() :: {:ok, non_neg_integer()} + def purge_compiler_modules() do + :elixir_code_server.call(:purge_compiler_modules) + end + + @doc """ + Compiles the given string. + + Returns a list of tuples where the first element is the module name + and the second one is its bytecode (as a binary). A `file` can be + given as second argument which will be used for reporting warnings + and errors. + + **Warning**: `string` can be any Elixir code and code can be executed with + the same privileges as the Erlang VM: this means that such code could + compromise the machine (for example by executing system commands). + Don't use `compile_string/2` with untrusted input (such as strings coming + from the network). + """ + @spec compile_string(List.Chars.t(), binary) :: [{module, binary}] + def compile_string(string, file \\ "nofile") when is_binary(file) do + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(to_charlist(string), file, fn _, _ -> :ok end) + end) + end + + @doc """ + Compiles the quoted expression. + + Returns a list of tuples where the first element is the module name and + the second one is its bytecode (as a binary). A `file` can be + given as second argument which will be used for reporting warnings + and errors. + """ + @spec compile_quoted(Macro.t(), binary) :: [{module, binary}] + def compile_quoted(quoted, file \\ "nofile") when is_binary(file) do + Module.ParallelChecker.verify(fn -> + :elixir_compiler.quoted(quoted, file, fn _, _ -> :ok end) + end) + end + + @doc """ + Compiles the given file. + + Accepts `relative_to` as an argument to tell where the file is located. + + Returns a list of tuples where the first element is the module name and + the second one is its bytecode (as a binary). Opposite to `require_file/2`, + it does not track the filename of the compiled file. + + If you would like to get the result of evaluating file rather than the + modules defined in it, see `eval_file/2`. + + For compiling many files concurrently, see `Kernel.ParallelCompiler.compile/2`. + """ + @doc since: "1.7.0" + @spec compile_file(binary, nil | binary) :: [{module, binary}] + def compile_file(file, relative_to \\ nil) when is_binary(file) do + Module.ParallelChecker.verify(fn -> + {charlist, file} = find_file!(file, relative_to) + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + end + + @doc """ + Ensures the given module is loaded. + + If the module is already loaded, this works as no-op. If the module + was not yet loaded, it tries to load it. + + If it succeeds in loading the module, it returns `{:module, module}`. + If not, returns `{:error, reason}` with the error reason. + + See the module documentation for more information on code loading. + + ## Examples + + iex> Code.ensure_loaded(Atom) + {:module, Atom} + + iex> Code.ensure_loaded(DoesNotExist) + {:error, :nofile} + + """ + @spec ensure_loaded(module) :: + {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure} + def ensure_loaded(module) when is_atom(module) do + :code.ensure_loaded(module) + end + + @doc """ + Ensures the given module is loaded. + + Similar to `ensure_loaded/1`, but returns `true` if the module + is already loaded or was successfully loaded. Returns `false` + otherwise. + + ## Examples + + iex> Code.ensure_loaded?(String) + true + + """ + @spec ensure_loaded?(module) :: boolean + def ensure_loaded?(module) when is_atom(module) do + match?({:module, ^module}, ensure_loaded(module)) + end + + @doc """ + Same as `ensure_loaded/1` but raises if the module cannot be loaded. + """ + @doc since: "1.12.0" + @spec ensure_loaded!(module) :: module + def ensure_loaded!(module) do + case ensure_loaded(module) do + {:module, module} -> + module + + {:error, reason} -> + raise ArgumentError, + "could not load module #{inspect(module)} due to reason #{inspect(reason)}" + end + end + + @doc """ + Ensures the given modules are loaded. + + Similar to `ensure_loaded/1`, but accepts a list of modules instead of a single + module, and loads all of them. + + If all modules load successfully, returns `:ok`. Otherwise, returns `{:error, errors}` + where `errors` is a list of tuples made of the module and the reason it failed to load. + + ## Examples + + iex> Code.ensure_all_loaded([Atom, String]) + :ok + + iex> Code.ensure_all_loaded([Atom, DoesNotExist]) + {:error, [{DoesNotExist, :nofile}]} + + """ + @doc since: "1.15.0" + @spec ensure_all_loaded([module]) :: :ok | {:error, [{module, reason}]} + when reason: :badfile | :nofile | :on_load_failure + def ensure_all_loaded(modules) when is_list(modules) do + :code.ensure_modules_loaded(modules) + end + + @doc """ + Same as `ensure_all_loaded/1` but raises if any of the modules cannot be loaded. + """ + @doc since: "1.15.0" + @spec ensure_all_loaded!([module]) :: :ok + def ensure_all_loaded!(modules) do + case ensure_all_loaded(modules) do + :ok -> + :ok + + {:error, errors} -> + formatted_errors = + errors + |> Enum.sort() + |> Enum.map_join("\n", fn {module, reason} -> + " * #{inspect(module)} due to reason #{inspect(reason)}" + end) + + raise ArgumentError, "could not load the following modules:\n\n" <> formatted_errors + end + end + + @doc """ + Similar to `ensure_compiled!/1` but indicates you can continue without said module. + + While `ensure_compiled!/1` indicates to the Elixir compiler you can + only continue when said module is available, this function indicates + you may continue compilation without said module. + + If it succeeds in loading the module, it returns `{:module, module}`. + If not, returns `{:error, reason}` with the error reason. + If the module being checked is currently in a compiler deadlock, + this function returns `{:error, :unavailable}`. Unavailable doesn't + necessarily mean the module doesn't exist, just that it is not currently + available, but it (or may not) become available in the future. + + Therefore, if you can only continue if the module is available, use + `ensure_compiled!/1` instead. In particular, do not do this: + + case Code.ensure_compiled(module) do + {:module, _} -> module + {:error, _} -> raise ... + end + + See the module documentation for more information on code loading. + """ + @spec ensure_compiled(module) :: + {:module, module} + | {:error, :embedded | :badfile | :nofile | :on_load_failure | :unavailable} + def ensure_compiled(module) when is_atom(module) do + ensure_compiled(module, :soft) + end + + @doc """ + Ensures the given module is compiled and loaded. + + If the module is already loaded, it works as no-op. If the module was + not compiled yet, `ensure_compiled!/1` halts the compilation of the caller + until the module given to `ensure_compiled!/1` becomes available or + all files for the current project have been compiled. If compilation + finishes and the module is not available or is in a deadlock, an error + is raised. + + Given this function halts compilation, use it carefully. In particular, + avoid using it to guess which modules are in the system. Overuse of this + function can also lead to deadlocks, where two modules check at the same time + if the other is compiled. This returns a specific unavailable error code, + where we cannot successfully verify a module is available or not. + + See the module documentation for more information on code loading. + """ + @doc since: "1.12.0" + @spec ensure_compiled!(module) :: module + def ensure_compiled!(module) do + case ensure_compiled(module, :hard) do + {:module, module} -> + module + + {:error, reason} -> + raise ArgumentError, + "could not load module #{inspect(module)} due to reason #{inspect(reason)}" + end + end + + defp ensure_compiled(module, mode) do + case :code.ensure_loaded(module) do + {:error, :nofile} = error -> + if can_await_module_compilation?() do + case Kernel.ErrorHandler.ensure_compiled(module, :module, mode) do + :found -> {:module, module} + :deadlock -> {:error, :unavailable} + :not_found -> {:error, :nofile} + end + else + error + end + + other -> + other + end + end + + @doc """ + Returns `true` if the module is loaded. + + This function doesn't attempt to load the module. For such behaviour, + `ensure_loaded?/1` can be used. + + ## Examples + + iex> Code.loaded?(Atom) + true + + iex> Code.loaded?(NotYetLoaded) + false + + """ + @doc since: "1.15.0" + @spec loaded?(module) :: boolean + def loaded?(module) do + :erlang.module_loaded(module) + end + + @doc """ + Returns true if the current process can await for module compilation. + + When compiling Elixir code via `Kernel.ParallelCompiler`, which is + used by Mix and `elixirc`, calling a module that has not yet been + compiled will block the caller until the module becomes available. + Executing Elixir scripts, such as passing a filename to `elixir`, + does not await. + """ + @doc since: "1.11.0" + @spec can_await_module_compilation? :: boolean + def can_await_module_compilation? do + :erlang.process_info(self(), :error_handler) == {:error_handler, Kernel.ErrorHandler} + end + + @doc false + @deprecated "Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)" + def ensure_compiled?(module) when is_atom(module) do + match?({:module, ^module}, ensure_compiled(module)) + end + + @doc ~S""" + Returns the docs for the given module or path to `.beam` file. + + When given a module name, it finds its BEAM code and reads the docs from it. + + When given a path to a `.beam` file, it will load the docs directly from that + file. + + It returns the term stored in the documentation chunk in the format defined by + [EEP 48](https://www.erlang.org/eeps/eep-0048.html) or `{:error, reason}` if + the chunk is not available. + + ## Examples + + # Module documentation of an existing module + iex> {:docs_v1, _, :elixir, _, %{"en" => module_doc}, _, _} = Code.fetch_docs(Atom) + iex> module_doc |> String.split("\n") |> Enum.at(0) + "Atoms are constants whose values are their own name." + + # A module that doesn't exist + iex> Code.fetch_docs(ModuleNotGood) + {:error, :module_not_found} + + """ + @doc since: "1.7.0" + @spec fetch_docs(module | String.t()) :: + {:docs_v1, annotation, beam_language, format, module_doc :: doc_content, metadata, + docs :: [doc_element]} + | {:error, :module_not_found | :chunk_not_found | {:invalid_chunk, binary}} + when annotation: :erl_anno.anno(), + beam_language: :elixir | :erlang | atom(), + doc_content: %{optional(binary) => binary} | :none | :hidden, + doc_element: + {{kind :: atom, function_name :: atom, arity}, annotation, signature, doc_content, + metadata}, + format: binary, + signature: [binary], + metadata: map + def fetch_docs(module_or_path) + + def fetch_docs(module) when is_atom(module) do + case get_beam_and_path(module) do + {bin, beam_path} -> + case fetch_docs_from_beam(bin) do + {:error, :chunk_not_found} -> + app_root = Path.expand(Path.join(["..", ".."]), beam_path) + path = Path.join([app_root, "doc", "chunks", "#{module}.chunk"]) + fetch_docs_from_chunk(path) + + other -> + other + end + + :error -> + case :code.is_loaded(module) do + {:file, :preloaded} -> + # The ERTS directory is not necessarily included in releases + # unless it is listed as an extra application. + case :code.lib_dir(:erts) do + path when is_list(path) -> + path = Path.join([path, "doc", "chunks", "#{module}.chunk"]) + fetch_docs_from_chunk(path) + + {:error, _} -> + {:error, :chunk_not_found} + end + + _ -> + {:error, :module_not_found} + end + end + end + + def fetch_docs(path) when is_binary(path) do + fetch_docs_from_beam(String.to_charlist(path)) + end + + defp get_beam_and_path(module) do + with {^module, beam, filename} <- :code.get_object_code(module), + {:ok, ^module} <- beam |> :beam_lib.info() |> Keyword.fetch(:module) do + {beam, filename} + else + _ -> :error + end + end + + @docs_chunk [?D, ?o, ?c, ?s] + + defp fetch_docs_from_beam(bin_or_path) do + case :beam_lib.chunks(bin_or_path, [@docs_chunk]) do + {:ok, {_module, [{@docs_chunk, bin}]}} -> + load_docs_chunk(bin) + + {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} -> + {:error, :chunk_not_found} + + {:error, :beam_lib, {:file_error, _, :enoent}} -> + {:error, :module_not_found} + end + end + + defp fetch_docs_from_chunk(path) do + case File.read(path) do + {:ok, bin} -> + load_docs_chunk(bin) + + {:error, _} -> + {:error, :chunk_not_found} + end + end + + defp load_docs_chunk(bin) do + :erlang.binary_to_term(bin) + rescue + _ -> + {:error, {:invalid_chunk, bin}} + end + + @doc false + @deprecated "Code.get_docs/2 always returns nil as its outdated documentation is no longer stored on BEAM files. Use Code.fetch_docs/1 instead" + def get_docs(_module, _kind) do + nil + end + + ## Helpers + + # Finds the file given the relative_to path. + # + # If the file is found, returns its path in binary, fails otherwise. + defp find_file!(file, relative_to) do + file = + if relative_to do + Path.expand(file, relative_to) + else + Path.expand(file) + end + + case File.read(file) do + {:ok, bin} -> {String.to_charlist(bin), file} + {:error, reason} -> raise Code.LoadError, file: file, reason: reason + end + end +end diff --git a/forge/lib/future/code/fragment.ex b/forge/lib/future/code/fragment.ex new file mode 100644 index 00000000..2645d135 --- /dev/null +++ b/forge/lib/future/code/fragment.ex @@ -0,0 +1,1132 @@ +# Copied from https://raw.githubusercontent.com/elixir-lang/elixir/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/fragment.ex +defmodule Future.Code.Fragment do + alias Future.Code, as: Code + + @moduledoc """ + This module provides conveniences for analyzing fragments of + textual code and extract available information whenever possible. + + This module should be considered experimental. + """ + + @type position :: {line :: pos_integer(), column :: pos_integer()} + + @doc """ + Receives a string and returns the cursor context. + + This function receives a string with an Elixir code fragment, + representing a cursor position, and based on the string, it + provides contextual information about the latest token. + The return of this function can then be used to provide tips, + suggestions, and autocompletion functionality. + + This function performs its analyses on tokens. This means + it does not understand how constructs are nested within each + other. See the "Limitations" section below. + + Consider adding a catch-all clause when handling the return + type of this function as new cursor information may be added + in future releases. + + ## Examples + + iex> Code.Fragment.cursor_context("") + :expr + + iex> Code.Fragment.cursor_context("hello_wor") + {:local_or_var, ~c"hello_wor"} + + ## Return values + + * `{:alias, charlist}` - the context is an alias, potentially + a nested one, such as `Hello.Wor` or `HelloWor` + + * `{:alias, inside_alias, charlist}` - the context is an alias, potentially + a nested one, where `inside_alias` is an expression `{:module_attribute, charlist}` + or `{:local_or_var, charlist}` and `charlist` is a static part + Examples are `__MODULE__.Submodule` or `@hello.Submodule` + + * `{:dot, inside_dot, charlist}` - the context is a dot + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, this may either be a remote call or a map + field access. Examples are `Hello.wor`, `:hello.wor`, `hello.wor`, + `Hello.nested.wor`, `hello.nested.wor`, and `@hello.world`. If `charlist` + is empty and `inside_dot` is an alias, then the autocompletion may either + be an alias or a remote call. + + * `{:dot_arity, inside_dot, charlist}` - the context is a dot arity + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, it must be a remote arity. Examples are + `Hello.world/`, `:hello.world/`, `hello.world/2`, and `@hello.world/2` + + * `{:dot_call, inside_dot, charlist}` - the context is a dot + call. This means parentheses or space have been added after the expression. + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, it must be a remote call. Examples are + `Hello.world(`, `:hello.world(`, `Hello.world `, `hello.world(`, `hello.world `, + and `@hello.world(` + + * `:expr` - may be any expression. Autocompletion may suggest an alias, + local or var + + * `{:local_or_var, charlist}` - the context is a variable or a local + (import or local) call, such as `hello_wor` + + * `{:local_arity, charlist}` - the context is a local (import or local) + arity, such as `hello_world/` + + * `{:local_call, charlist}` - the context is a local (import or local) + call, such as `hello_world(` and `hello_world ` + + * `{:anonymous_call, inside_caller}` - the context is an anonymous + call, such as `fun.(` and `@fun.(`. + + * `{:module_attribute, charlist}` - the context is a module attribute, + such as `@hello_wor` + + * `{:operator, charlist}` - the context is an operator, such as `+` or + `==`. Note textual operators, such as `when` do not appear as operators + but rather as `:local_or_var`. `@` is never an `:operator` and always a + `:module_attribute` + + * `{:operator_arity, charlist}` - the context is an operator arity, which + is an operator followed by /, such as `+/`, `not/` or `when/` + + * `{:operator_call, charlist}` - the context is an operator call, which is + an operator followed by space, such as `left + `, `not ` or `x when ` + + * `:none` - no context possible + + * `{:sigil, charlist}` - the context is a sigil. It may be either the beginning + of a sigil, such as `~` or `~s`, or an operator starting with `~`, such as + `~>` and `~>>` + + * `{:struct, inside_struct}` - the context is a struct, such as `%`, `%UR` or `%URI`. + `inside_struct` can either be a `charlist` in case of a static alias or an + expression `{:alias, inside_alias, charlist}`, `{:module_attribute, charlist}`, + `{:local_or_var, charlist}`, `{:dot, inside_dot, charlist}` + + * `{:unquoted_atom, charlist}` - the context is an unquoted atom. This + can be any atom or an atom representing a module + + We recommend looking at the test suite of this function for a complete list + of examples and their return values. + + ## Limitations + + The analysis is based on the current token, by analysing the last line of + the input. For example, this code: + + iex> Code.Fragment.cursor_context("%URI{") + :expr + + returns `:expr`, which suggests any variable, local function or alias + could be used. However, given we are inside a struct, the best suggestion + would be a struct field. In such cases, you can use + `container_cursor_to_quoted`, which will return the container of the AST + the cursor is currently within. You can then analyse this AST to provide + completion of field names. + + As a consequence of its token-based implementation, this function considers + only the last line of the input. This means it will show suggestions inside + strings, heredocs, etc, which is intentional as it helps with doctests, + references, and more. + """ + @doc since: "1.13.0" + @spec cursor_context(List.Chars.t(), keyword()) :: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:dot_arity, inside_dot, charlist} + | {:dot_call, inside_dot, charlist} + | :expr + | {:local_or_var, charlist} + | {:local_arity, charlist} + | {:local_call, charlist} + | {:anonymous_call, inside_caller} + | {:module_attribute, charlist} + | {:operator, charlist} + | {:operator_arity, charlist} + | {:operator_call, charlist} + | :none + | {:sigil, charlist} + | {:struct, inside_struct} + | {:unquoted_atom, charlist} + when inside_dot: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:module_attribute, charlist} + | {:unquoted_atom, charlist} + | {:var, charlist} + | :expr, + inside_alias: + {:local_or_var, charlist} + | {:module_attribute, charlist}, + inside_struct: + charlist + | {:alias, inside_alias, charlist} + | {:local_or_var, charlist} + | {:module_attribute, charlist} + | {:dot, inside_dot, charlist}, + inside_caller: {:var, charlist} | {:module_attribute, charlist} + def cursor_context(fragment, opts \\ []) + + def cursor_context(fragment, opts) + when (is_binary(fragment) or is_list(fragment)) and is_list(opts) do + fragment + |> last_line() + |> :lists.reverse() + |> codepoint_cursor_context(opts) + |> elem(0) + end + + def cursor_context(other, opts) when is_list(opts) do + cursor_context(to_charlist(other), opts) + end + + @operators ~c"\\<>+-*/:=|&~^%!" + @starter_punctuation ~c",([{;" + @non_starter_punctuation ~c")]}\"'.$" + @space ~c"\t\s" + @trailing_identifier ~c"?!" + @tilde_op_prefix ~c"<=~" + + @non_identifier @trailing_identifier ++ + @operators ++ @starter_punctuation ++ @non_starter_punctuation ++ @space + + @textual_operators ~w(when not and or in)c + @keywords ~w(do end after else catch rescue fn true false nil)c + + defp codepoint_cursor_context(reverse, _opts) do + {stripped, spaces} = strip_spaces(reverse, 0) + + case stripped do + # It is empty + [] -> {:expr, 0} + # Structs + [?%, ?:, ?: | _] -> {{:struct, ~c""}, 1} + [?%, ?: | _] -> {{:unquoted_atom, ~c"%"}, 2} + [?% | _] -> {{:struct, ~c""}, 1} + # Token/AST only operators + [?>, ?= | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0} + [?>, ?- | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0} + # Two-digit containers + [?<, ?< | rest] when rest == [] or hd(rest) != ?< -> {:expr, 0} + # Ambiguity around : + [?: | rest] when rest == [] or hd(rest) != ?: -> unquoted_atom_or_expr(spaces) + # Dots + [?.] -> {:none, 0} + [?. | rest] when hd(rest) not in ~c".:" -> dot(rest, spaces + 1, ~c"") + # It is a local or remote call with parens + [?( | rest] -> call_to_cursor_context(strip_spaces(rest, spaces + 1)) + # A local arity definition + [?/ | rest] -> arity_to_cursor_context(strip_spaces(rest, spaces + 1)) + # Starting a new expression + [h | _] when h in @starter_punctuation -> {:expr, 0} + # It is a local or remote call without parens + rest when spaces > 0 -> call_to_cursor_context({rest, spaces}) + # It is an identifier + _ -> identifier_to_cursor_context(reverse, 0, false) + end + end + + defp strip_spaces([h | rest], count) when h in @space, do: strip_spaces(rest, count + 1) + defp strip_spaces(rest, count), do: {rest, count} + + defp unquoted_atom_or_expr(0), do: {{:unquoted_atom, ~c""}, 1} + defp unquoted_atom_or_expr(_), do: {:expr, 0} + + defp arity_to_cursor_context({reverse, spaces}) do + case identifier_to_cursor_context(reverse, spaces, true) do + {{:local_or_var, acc}, count} -> {{:local_arity, acc}, count} + {{:dot, base, acc}, count} -> {{:dot_arity, base, acc}, count} + {{:operator, acc}, count} -> {{:operator_arity, acc}, count} + {_, _} -> {:none, 0} + end + end + + defp call_to_cursor_context({reverse, spaces}) do + with [?. | rest] <- reverse, + {rest, spaces} = strip_spaces(rest, spaces), + [h | _] when h not in @non_identifier <- rest do + case identifier_to_cursor_context(rest, spaces, true) do + {{:local_or_var, acc}, count} -> {{:anonymous_call, {:var, acc}}, count + 1} + {{:module_attribute, _} = attr, count} -> {{:anonymous_call, attr}, count + 1} + {_, _} -> {:none, 0} + end + else + _ -> + case identifier_to_cursor_context(reverse, spaces, true) do + {{:local_or_var, acc}, count} -> {{:local_call, acc}, count} + {{:dot, base, acc}, count} -> {{:dot_call, base, acc}, count} + {{:operator, acc}, count} -> {{:operator_call, acc}, count} + {_, _} -> {:none, 0} + end + end + end + + defp identifier_to_cursor_context([?., ?., ?: | _], n, _), do: {{:unquoted_atom, ~c".."}, n + 3} + defp identifier_to_cursor_context([?., ?., ?. | _], n, _), do: {{:local_or_var, ~c"..."}, n + 3} + defp identifier_to_cursor_context([?., ?: | _], n, _), do: {{:unquoted_atom, ~c"."}, n + 2} + defp identifier_to_cursor_context([?., ?. | _], n, _), do: {{:operator, ~c".."}, n + 2} + + defp identifier_to_cursor_context(reverse, count, call_op?) do + case identifier(reverse, count) do + :none -> + {:none, 0} + + :operator -> + operator(reverse, count, [], call_op?) + + {:struct, {:module_attribute, acc}, count} -> + {{:struct, {:module_attribute, acc}}, count + 1} + + {:module_attribute, acc, count} -> + {{:module_attribute, acc}, count} + + {:sigil, acc, count} -> + {{:sigil, acc}, count} + + {:unquoted_atom, acc, count} -> + {{:unquoted_atom, acc}, count} + + {:alias, rest, acc, count} -> + case strip_spaces(rest, count) do + {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. -> + nested_alias(rest, count + 1, acc) + + {~c"%" ++ _, count} -> + {{:struct, acc}, count + 1} + + _ -> + {{:alias, acc}, count} + end + + {:identifier, _, acc, count} when call_op? and acc in @textual_operators -> + {{:operator, acc}, count} + + {:identifier, [?%], acc, count} -> + case identifier_to_cursor_context(acc |> Enum.reverse(), count, true) do + {{:local_or_var, _} = identifier, _} -> {{:struct, identifier}, count + 1} + _ -> {:none, 0} + end + + {:identifier, rest, acc, count} -> + case strip_spaces(rest, count) do + {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. -> + dot(rest, count + 1, acc) + + _ -> + {{:local_or_var, acc}, count} + end + end + end + + defp identifier([?? | rest], count), do: check_identifier(rest, count + 1, [??]) + defp identifier([?! | rest], count), do: check_identifier(rest, count + 1, [?!]) + defp identifier(rest, count), do: check_identifier(rest, count, []) + + defp check_identifier([h | t], count, acc) when h not in @non_identifier, + do: rest_identifier(t, count + 1, [h | acc]) + + defp check_identifier(_, _, _), do: :operator + + defp rest_identifier([h | rest], count, acc) when h not in @non_identifier do + rest_identifier(rest, count + 1, [h | acc]) + end + + defp rest_identifier(rest, count, [?@ | acc]) do + case tokenize_identifier(rest, count, acc) do + {:identifier, [?% | _rest], acc, count} -> {:struct, {:module_attribute, acc}, count} + {:identifier, _rest, acc, count} -> {:module_attribute, acc, count} + :none when acc == [] -> {:module_attribute, ~c"", count} + _ -> :none + end + end + + defp rest_identifier([?~ | rest], count, [letter]) + when (letter in ?A..?Z or letter in ?a..?z) and + (rest == [] or hd(rest) not in @tilde_op_prefix) do + {:sigil, [letter], count + 1} + end + + defp rest_identifier([?: | rest], count, acc) when rest == [] or hd(rest) != ?: do + case String.Tokenizer.tokenize(acc) do + {_, _, [], _, _, _} -> {:unquoted_atom, acc, count + 1} + _ -> :none + end + end + + defp rest_identifier([?? | _], _count, _acc) do + :none + end + + defp rest_identifier(rest, count, acc) do + tokenize_identifier(rest, count, acc) + end + + defp tokenize_identifier(rest, count, acc) do + case String.Tokenizer.tokenize(acc) do + # Not actually an atom cause rest is not a : + {:atom, _, _, _, _, _} -> + :none + + # Aliases must be ascii only + {:alias, _, _, _, false, _} -> + :none + + {kind, _, [], _, _, extra} -> + if :at in extra do + :none + else + {kind, rest, acc, count} + end + + _ -> + :none + end + end + + defp nested_alias(rest, count, acc) do + {rest, count} = strip_spaces(rest, count) + + case identifier_to_cursor_context(rest, count, true) do + {{:struct, prev}, count} when is_list(prev) -> + {{:struct, prev ++ ~c"." ++ acc}, count} + + {{:struct, {:alias, parent, prev}}, count} -> + {{:struct, {:alias, parent, prev ++ ~c"." ++ acc}}, count} + + {{:struct, prev}, count} -> + {{:struct, {:alias, prev, acc}}, count} + + {{:alias, prev}, count} -> + {{:alias, prev ++ ~c"." ++ acc}, count} + + {{:alias, parent, prev}, count} -> + {{:alias, parent, prev ++ ~c"." ++ acc}, count} + + {{:local_or_var, prev}, count} -> + {{:alias, {:local_or_var, prev}, acc}, count} + + {{:module_attribute, prev}, count} -> + {{:alias, {:module_attribute, prev}, acc}, count} + + _ -> + {:none, 0} + end + end + + defp dot(rest, count, acc) do + {rest, count} = strip_spaces(rest, count) + + case identifier_to_cursor_context(rest, count, true) do + {{:local_or_var, var}, count} -> + {{:dot, {:var, var}, acc}, count} + + {{:unquoted_atom, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:alias, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:alias, _, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:struct, inner}, count} when is_list(inner) -> + {{:struct, {:dot, {:alias, inner}, acc}}, count} + + {{:struct, inner}, count} -> + {{:struct, {:dot, inner, acc}}, count} + + {{:dot, _, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:module_attribute, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {:expr, count} -> + {{:dot, :expr, acc}, count} + + {_, _} -> + {:none, 0} + end + end + + defp operator([h | rest], count, acc, call_op?) when h in @operators do + operator(rest, count + 1, [h | acc], call_op?) + end + + # If we are opening a sigil, ignore the operator. + defp operator([letter, ?~ | rest], _count, [op], _call_op?) + when op in ~c"<|/" and (letter in ?A..?Z or letter in ?a..?z) and + (rest == [] or hd(rest) not in @tilde_op_prefix) do + {:none, 0} + end + + defp operator(rest, count, ~c"~", call_op?) do + {rest, _} = strip_spaces(rest, count) + + if call_op? or match?([?. | rest] when rest == [] or hd(rest) != ?., rest) do + {:none, 0} + else + {{:sigil, ~c""}, count} + end + end + + defp operator([?) | rest], _, [], true) when hd(rest) != ?? do + {:expr, 0} + end + + defp operator(rest, count, acc, _call_op?) do + case :future_elixir_tokenizer.tokenize(acc, 1, 1, []) do + {:ok, _, _, _, [{:atom, _, _}], []} -> + {{:unquoted_atom, tl(acc)}, count} + + {:ok, _, _, _, [{_, _, op}], []} -> + {rest, dot_count} = strip_spaces(rest, count) + + cond do + Code.Identifier.unary_op(op) == :error and + Code.Identifier.binary_op(op) == :error -> + {:none, 0} + + match?([?. | rest] when rest == [] or hd(rest) != ?., rest) -> + dot(tl(rest), dot_count + 1, acc) + + true -> + {{:operator, acc}, count} + end + + _ -> + {:none, 0} + end + end + + @doc """ + Receives a string and returns the surround context. + + This function receives a string with an Elixir code fragment + and a `position`. It returns a map containing the beginning + and ending of the identifier alongside its context, or `:none` + if there is nothing with a known context. This is useful to + provide mouse-over and highlight functionality in editors. + + The difference between `cursor_context/2` and `surround_context/3` + is that the former assumes the expression in the code fragment + is incomplete. For example, `do` in `cursor_context/2` may be + a keyword or a variable or a local call, while `surround_context/3` + assumes the expression in the code fragment is complete, therefore + `do` would always be a keyword. + + The `position` contains both the `line` and `column`, both starting + with the index of 1. The column must precede the surrounding expression. + For example, the expression `foo`, will return something for the columns + 1, 2, and 3, but not 4: + + foo + ^ column 1 + + foo + ^ column 2 + + foo + ^ column 3 + + foo + ^ column 4 + + The returned map contains the column the expression starts and the + first column after the expression ends. + + Similar to `cursor_context/2`, this function is also token-based + and may not be accurate under all circumstances. See the + "Return values" and "Limitations" section under `cursor_context/2` + for more information. + + ## Examples + + iex> Code.Fragment.surround_context("foo", {1, 1}) + %{begin: {1, 1}, context: {:local_or_var, ~c"foo"}, end: {1, 4}} + + ## Differences to `cursor_context/2` + + Because `surround_context/3` attempts to capture complex expressions, + it has some differences to `cursor_context/2`: + + * `dot_call`/`dot_arity` and `operator_call`/`operator_arity` + are collapsed into `dot` and `operator` contexts respectively + as there aren't any meaningful distinctions between them + + * On the other hand, this function still makes a distinction between + `local_call`/`local_arity` and `local_or_var`, since the latter can + be a local or variable + + * `@` when not followed by any identifier is returned as `{:operator, '@'}` + (in contrast to `{:module_attribute, ''}` in `cursor_context/2` + + * This function never returns empty sigils `{:sigil, ''}` or empty structs + `{:struct, ''}` as context + + * This function returns keywords as `{:keyword, 'do'}` + + * This function never returns `:expr` + + We recommend looking at the test suite of this function for a complete list + of examples and their return values. + """ + @doc since: "1.13.0" + @spec surround_context(List.Chars.t(), position(), keyword()) :: + %{begin: position, end: position, context: context} | :none + when context: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:local_or_var, charlist} + | {:local_arity, charlist} + | {:local_call, charlist} + | {:module_attribute, charlist} + | {:operator, charlist} + | {:sigil, charlist} + | {:struct, inside_struct} + | {:unquoted_atom, charlist} + | {:keyword, charlist}, + inside_dot: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:module_attribute, charlist} + | {:unquoted_atom, charlist} + | {:var, charlist} + | :expr, + inside_alias: + {:local_or_var, charlist} + | {:module_attribute, charlist}, + inside_struct: + charlist + | {:alias, inside_alias, charlist} + | {:local_or_var, charlist} + | {:module_attribute, charlist} + | {:dot, inside_dot, charlist} + def surround_context(fragment, position, options \\ []) + + def surround_context(string, {line, column}, opts) + when (is_binary(string) or is_list(string)) and is_list(opts) do + {charlist, lines_before_lengths, lines_current_and_after_lengths} = + surround_line(string, line, column) + + prepended_columns = Enum.sum(lines_before_lengths) + + charlist + |> position_surround_context(line, column + prepended_columns, opts) + |> to_multiline_range( + prepended_columns, + lines_before_lengths, + lines_current_and_after_lengths + ) + end + + def surround_context(other, {_, _} = position, opts) do + surround_context(to_charlist(other), position, opts) + end + + defp position_surround_context(charlist, line, column, opts) + when is_integer(line) and line >= 1 and is_integer(column) and column >= 1 do + {reversed_pre, post} = string_reverse_at(charlist, column - 1, []) + {reversed_pre, post} = adjust_position(reversed_pre, post) + + case take_identifier(post, []) do + {_, [], _} -> + maybe_operator(reversed_pre, post, line, opts) + + {:identifier, reversed_post, rest} -> + {rest, _} = strip_spaces(rest, 0) + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:struct, acc}, offset} -> + build_surround({:struct, acc}, reversed, line, offset) + + {{:alias, acc}, offset} -> + build_surround({:alias, acc}, reversed, line, offset) + + {{:alias, parent, acc}, offset} -> + build_surround({:alias, parent, acc}, reversed, line, offset) + + {{:dot, _, [_ | _]} = dot, offset} -> + build_surround(dot, reversed, line, offset) + + {{:local_or_var, acc}, offset} when hd(rest) == ?( -> + build_surround({:local_call, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when hd(rest) == ?/ -> + build_surround({:local_arity, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when acc in @textual_operators -> + build_surround({:operator, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when acc in @keywords -> + build_surround({:keyword, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} -> + build_surround({:local_or_var, acc}, reversed, line, offset) + + {{:module_attribute, ~c""}, offset} -> + build_surround({:operator, ~c"@"}, reversed, line, offset) + + {{:module_attribute, acc}, offset} -> + build_surround({:module_attribute, acc}, reversed, line, offset) + + {{:sigil, acc}, offset} -> + build_surround({:sigil, acc}, reversed, line, offset) + + {{:unquoted_atom, acc}, offset} -> + build_surround({:unquoted_atom, acc}, reversed, line, offset) + + _ -> + maybe_operator(reversed_pre, post, line, opts) + end + + {:alias, reversed_post, _rest} -> + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:alias, acc}, offset} -> + build_surround({:alias, acc}, reversed, line, offset) + + {{:alias, parent, acc}, offset} -> + build_surround({:alias, parent, acc}, reversed, line, offset) + + {{:struct, acc}, offset} -> + build_surround({:struct, acc}, reversed, line, offset) + + _ -> + :none + end + end + end + + defp maybe_operator(reversed_pre, post, line, opts) do + case take_operator(post, []) do + {[], _rest} -> + :none + + {reversed_post, rest} -> + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:operator, acc}, offset} -> + build_surround({:operator, acc}, reversed, line, offset) + + {{:sigil, ~c""}, offset} when hd(rest) in ?A..?Z or hd(rest) in ?a..?z -> + build_surround({:sigil, [hd(rest)]}, [hd(rest) | reversed], line, offset + 1) + + {{:dot, _, [_ | _]} = dot, offset} -> + build_surround(dot, reversed, line, offset) + + _ -> + :none + end + end + end + + defp build_surround(context, reversed, line, offset) do + {post, reversed_pre} = enum_reverse_at(reversed, offset, []) + pre = :lists.reverse(reversed_pre) + pre_length = :string.length(pre) + 1 + + %{ + context: context, + begin: {line, pre_length}, + end: {line, pre_length + :string.length(post)} + } + end + + defp take_identifier([h | t], acc) when h in @trailing_identifier, + do: {:identifier, [h | acc], t} + + defp take_identifier([h | t], acc) when h not in @non_identifier, + do: take_identifier(t, [h | acc]) + + defp take_identifier(rest, acc) do + with {[?. | t], _} <- strip_spaces(rest, 0), + {[h | _], _} when h in ?A..?Z <- strip_spaces(t, 0) do + take_alias(rest, acc) + else + _ -> {:identifier, acc, rest} + end + end + + defp take_alias([h | t], acc) when h in ?A..?Z or h in ?a..?z or h in ?0..?9 or h == ?_, + do: take_alias(t, [h | acc]) + + defp take_alias(rest, acc) do + with {[?. | t], acc} <- move_spaces(rest, acc), + {[h | t], acc} when h in ?A..?Z <- move_spaces(t, [?. | acc]) do + take_alias(t, [h | acc]) + else + _ -> {:alias, acc, rest} + end + end + + defp take_operator([h | t], acc) when h in @operators, do: take_operator(t, [h | acc]) + defp take_operator([h | t], acc) when h == ?., do: take_operator(t, [h | acc]) + defp take_operator(rest, acc), do: {acc, rest} + + # Unquoted atom handling + defp adjust_position(reversed_pre, [?: | post]) + when hd(post) != ?: and (reversed_pre == [] or hd(reversed_pre) != ?:) do + {[?: | reversed_pre], post} + end + + defp adjust_position(reversed_pre, [?% | post]) do + adjust_position([?% | reversed_pre], post) + end + + # Dot/struct handling + defp adjust_position(reversed_pre, post) do + case move_spaces(post, reversed_pre) do + # If we are between spaces and a dot, move past the dot + {[?. | post], reversed_pre} when hd(post) != ?. and hd(reversed_pre) != ?. -> + {post, reversed_pre} = move_spaces(post, [?. | reversed_pre]) + {reversed_pre, post} + + _ -> + case strip_spaces(reversed_pre, 0) do + # If there is a dot to our left, make sure to move to the first character + {[?. | rest], _} when rest == [] or hd(rest) not in ~c".:" -> + {post, reversed_pre} = move_spaces(post, reversed_pre) + {reversed_pre, post} + + # If there is a % to our left, make sure to move to the first character + {[?% | _], _} -> + case move_spaces(post, reversed_pre) do + {[h | _] = post, reversed_pre} when h in ?A..?Z -> + {reversed_pre, post} + + _ -> + {reversed_pre, post} + end + + _ -> + {reversed_pre, post} + end + end + end + + defp move_spaces([h | t], acc) when h in @space, do: move_spaces(t, [h | acc]) + defp move_spaces(t, acc), do: {t, acc} + + defp string_reverse_at(charlist, 0, acc), do: {acc, charlist} + + defp string_reverse_at(charlist, n, acc) do + case :unicode_util.gc(charlist) do + [gc | cont] when is_integer(gc) -> string_reverse_at(cont, n - 1, [gc | acc]) + [gc | cont] when is_list(gc) -> string_reverse_at(cont, n - 1, :lists.reverse(gc, acc)) + [] -> {acc, []} + end + end + + defp enum_reverse_at([h | t], n, acc) when n > 0, do: enum_reverse_at(t, n - 1, [h | acc]) + defp enum_reverse_at(rest, _, acc), do: {acc, rest} + + defp last_line(binary) when is_binary(binary) do + [last_line | lines_reverse] = + binary + |> String.split(["\r\n", "\n"]) + |> Enum.reverse() + + prepend_cursor_lines(lines_reverse, String.to_charlist(last_line)) + end + + defp last_line(charlist) when is_list(charlist) do + [last_line | lines_reverse] = + charlist + |> :string.replace(~c"\r\n", ~c"\n", :all) + |> :string.join(~c"") + |> :string.split(~c"\n", :all) + |> Enum.reverse() + + prepend_cursor_lines(lines_reverse, last_line) + end + + defp prepend_cursor_lines(lines, last_line) do + with [line | lines] <- lines, + {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true), + true <- incomplete? or starts_with_dot?(last_line) do + prepend_cursor_lines(lines, Enum.reverse(trimmed_line, last_line)) + else + _ -> last_line + end + end + + defp starts_with_dot?([?. | _]), do: true + defp starts_with_dot?([h | t]) when h in @space, do: starts_with_dot?(t) + defp starts_with_dot?(_), do: false + + defp ends_as_incomplete([?# | _], acc, incomplete?), + do: {acc, incomplete?} + + defp ends_as_incomplete([h | t], acc, _incomplete?) when h in [?(, ?.], + do: ends_as_incomplete(t, [h | acc], true) + + defp ends_as_incomplete([h | t], acc, incomplete?) when h in @space, + do: ends_as_incomplete(t, [h | acc], incomplete?) + + defp ends_as_incomplete([h | t], acc, _incomplete?), + do: ends_as_incomplete(t, [h | acc], false) + + defp ends_as_incomplete([], acc, incomplete?), + do: {acc, incomplete?} + + defp surround_line(binary, line, column) when is_binary(binary) do + binary + |> String.split(["\r\n", "\n"]) + |> Enum.map(&String.to_charlist/1) + |> surround_lines(line, column) + end + + defp surround_line(charlist, line, column) when is_list(charlist) do + charlist + |> :string.replace(~c"\r\n", ~c"\n", :all) + |> :string.join(~c"") + |> :string.split(~c"\n", :all) + |> surround_lines(line, column) + end + + defp surround_lines(lines, line, column) do + {lines_before_reverse, cursor_line, lines_after} = split_at(lines, line, []) + {trimmed_cursor_line, incomplete?} = ends_as_incomplete(to_charlist(cursor_line), [], true) + + reversed_cursor_line = + if column - 1 > length(trimmed_cursor_line) do + # Don't strip comments if cursor is inside a comment + Enum.reverse(cursor_line) + else + trimmed_cursor_line + end + + {cursor_line, after_lengths} = + append_surround_lines(lines_after, [], [reversed_cursor_line], incomplete?) + + {cursor_line, before_lengths} = prepend_surround_lines(lines_before_reverse, [], cursor_line) + {cursor_line, before_lengths, [length(reversed_cursor_line) | after_lengths]} + end + + defp split_at([line], _, acc), do: {acc, line, []} + defp split_at([line | lines], 1, acc), do: {acc, line, lines} + defp split_at([line | lines], count, acc), do: split_at(lines, count - 1, [line | acc]) + + defp prepend_surround_lines(lines, lengths, last_line) do + with [line | lines] <- lines, + {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true), + true <- incomplete? or starts_with_dot?(last_line) do + lengths = [length(trimmed_line) | lengths] + prepend_surround_lines(lines, lengths, Enum.reverse(trimmed_line, last_line)) + else + _ -> {last_line, Enum.reverse(lengths)} + end + end + + defp append_surround_lines(lines, lengths, acc_lines, incomplete?) do + with [line | lines] <- lines, + line = to_charlist(line), + true <- incomplete? or starts_with_dot?(line) do + {trimmed_line, incomplete?} = ends_as_incomplete(line, [], true) + lengths = [length(trimmed_line) | lengths] + append_surround_lines(lines, lengths, [trimmed_line | acc_lines], incomplete?) + else + _ -> {Enum.reduce(acc_lines, [], &Enum.reverse/2), Enum.reverse(lengths)} + end + end + + defp to_multiline_range(:none, _, _, _), do: :none + + defp to_multiline_range( + %{begin: {begin_line, begin_column}, end: {end_line, end_column}} = context, + prepended, + lines_before_lengths, + lines_current_and_after_lengths + ) do + {begin_line, begin_column} = + Enum.reduce_while(lines_before_lengths, {begin_line, begin_column - prepended}, fn + line_length, {acc_line, acc_column} -> + if acc_column < 1 do + {:cont, {acc_line - 1, acc_column + line_length}} + else + {:halt, {acc_line, acc_column}} + end + end) + + {end_line, end_column} = + Enum.reduce_while(lines_current_and_after_lengths, {end_line, end_column - prepended}, fn + line_length, {acc_line, acc_column} -> + if acc_column > line_length + 1 do + {:cont, {acc_line + 1, acc_column - line_length}} + else + {:halt, {acc_line, acc_column}} + end + end) + + %{context | begin: {begin_line, begin_column}, end: {end_line, end_column}} + end + + @doc """ + Receives a string and returns a quoted expression + with the cursor AST position within its parent expression. + + This function receives a string with an Elixir code fragment, + representing a cursor position, and converts such string to + AST with the inclusion of special `__cursor__()` node representing + the cursor position within its container (i.e. its parent). + + For example, take this code, which would be given as input: + + max(some_value, + + This function will return the AST equivalent to: + + max(some_value, __cursor__()) + + In other words, this function is capable of closing any open + brackets and insert the cursor position. Other content at the + cursor position which is not a parent is discarded. + For example, if this is given as input: + + max(some_value, another_val + + It will return the same AST: + + max(some_value, __cursor__()) + + Similarly, if only this is given: + + max(some_va + + Then it returns: + + max(__cursor__()) + + Calls without parenthesis are also supported, as we assume the + brackets are implicit. + + Tuples, lists, maps, and binaries all retain the cursor position: + + max(some_value, [1, 2, + + Returns the following AST: + + max(some_value, [1, 2, __cursor__()]) + + Keyword lists (and do-end blocks) are also retained. The following: + + if(some_value, do: + if(some_value, do: :token + if(some_value, do: 1 + val + + all return: + + if(some_value, do: __cursor__()) + + For multi-line blocks, all previous lines are preserved. + + The AST returned by this function is not safe to evaluate but + it can be analyzed and expanded. + + ## Examples + + Function call: + + iex> Code.Fragment.container_cursor_to_quoted("max(some_value, ") + {:ok, {:max, [line: 1], [{:some_value, [line: 1], nil}, {:__cursor__, [line: 1], []}]}} + + Containers (for example, a list): + + iex> Code.Fragment.container_cursor_to_quoted("[some, value") + {:ok, [{:some, [line: 1], nil}, {:__cursor__, [line: 1], []}]} + + If an expression is complete, then the whole expression is discarded + and only the parent is returned: + + iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var)") + {:ok, {:if, [line: 1], [{:__cursor__, [line: 1], []}]}} + + this means complete expressions themselves return only the cursor: + + iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var))") + {:ok, {:__cursor__, [line: 1], []}} + + Operators are also included from Elixir v1.15: + + iex> Code.Fragment.container_cursor_to_quoted("foo +") + {:ok, {:+, [line: 1], [{:foo, [line: 1], nil}, {:__cursor__, [line: 1], []}]}} + + ## Options + + * `:file` - the filename to be reported in case of parsing errors. + Defaults to `"nofile"`. + + * `:line` - the starting line of the string being parsed. + Defaults to 1. + + * `:column` - the starting column of the string being parsed. + Defaults to 1. + + * `:columns` - when `true`, attach a `:column` key to the quoted + metadata. Defaults to `false`. + + * `:token_metadata` - when `true`, includes token-related + metadata in the expression AST, such as metadata for `do` and `end` + tokens, for closing tokens, end of expressions, as well as delimiters + for sigils. See `t:Macro.metadata/0`. Defaults to `false`. + + * `:literal_encoder` - a function to encode literals in the AST. + See the documentation for `Code.string_to_quoted/2` for more information. + + """ + @doc since: "1.13.0" + @spec container_cursor_to_quoted(List.Chars.t(), keyword()) :: + {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}} + def container_cursor_to_quoted(fragment, opts \\ []) do + opts = Keyword.take(opts, [:columns, :token_metadata, :literal_encoder]) + opts = [cursor_completion: true, emit_warnings: false] ++ opts + + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + case :future_elixir_tokenizer.tokenize(to_charlist(fragment), line, column, opts) do + {:ok, line, column, _warnings, rev_tokens, rev_terminators} -> + tokens = :lists.reverse(rev_tokens, rev_terminators) + + case :future_elixir.tokens_to_quoted(tokens, file, opts) do + {:ok, ast} -> + {:ok, ast} + + {:error, error} -> + # In case parsing fails, we give it another shot but handling fn/do/else/catch/rescue/after. + tokens = + :lists.reverse( + rev_tokens, + [{:stab_op, {line, column, nil}, :->}, {nil, {line, column + 2, nil}}] ++ + Enum.map(rev_terminators, fn tuple -> + {line, column, info} = elem(tuple, 1) + put_elem(tuple, 1, {line, column + 5, info}) + end) + ) + + case :future_elixir.tokens_to_quoted(tokens, file, opts) do + {:ok, ast} -> {:ok, ast} + {:error, _} -> {:error, error} + end + end + + {:error, info, _rest, _warnings, _so_far} -> + {:error, :future_elixir.format_token_error(info)} + end + end +end diff --git a/forge/lib/future/code/indentifier.ex b/forge/lib/future/code/indentifier.ex new file mode 100644 index 00000000..ab4aac3d --- /dev/null +++ b/forge/lib/future/code/indentifier.ex @@ -0,0 +1,153 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/identifier.ex +defmodule Future.Code.Identifier do + @moduledoc false + + @doc """ + Checks if the given identifier is an unary op. + + ## Examples + + iex> Code.Identifier.unary_op(:+) + {:non_associative, 300} + + """ + @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error + def unary_op(op) do + cond do + op in [:&, :...] -> {:non_associative, 90} + op in [:!, :^, :not, :+, :-, :"~~~"] -> {:non_associative, 300} + op in [:@] -> {:non_associative, 320} + true -> :error + end + end + + @doc """ + Checks if the given identifier is a binary op. + + ## Examples + + iex> Code.Identifier.binary_op(:+) + {:left, 210} + + """ + @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error + def binary_op(op) do + cond do + op in [:<-, :\\] -> {:left, 40} + op in [:when] -> {:right, 50} + op in [:"::"] -> {:right, 60} + op in [:|] -> {:right, 70} + op in [:=] -> {:right, 100} + op in [:||, :|||, :or] -> {:left, 120} + op in [:&&, :&&&, :and] -> {:left, 130} + op in [:==, :!=, :=~, :===, :!==] -> {:left, 140} + op in [:<, :<=, :>=, :>] -> {:left, 150} + op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :"<|>"] -> {:left, 160} + op in [:in] -> {:left, 170} + op in [:"^^^"] -> {:left, 180} + op in [:++, :--, :.., :<>, :+++, :---] -> {:right, 200} + op in [:+, :-] -> {:left, 210} + op in [:*, :/] -> {:left, 220} + op in [:**] -> {:left, 230} + op in [:.] -> {:left, 310} + true -> :error + end + end + + @doc """ + Extracts the name and arity of the parent from the anonymous function identifier. + """ + # Example of this format: -NAME/ARITY-fun-COUNT- + def extract_anonymous_fun_parent(atom) when is_atom(atom) do + with "-" <> rest <- Atom.to_string(atom), + [trailing | reversed] = rest |> String.split("/") |> Enum.reverse(), + [arity, _inner, _count, ""] <- String.split(trailing, "-") do + {reversed |> Enum.reverse() |> Enum.join("/") |> String.to_atom(), arity} + else + _ -> :error + end + end + + @doc """ + Escapes the given identifier. + """ + @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) :: + {escaped :: iolist(), remaining :: binary()} + def escape(binary, char, limit \\ :infinity, fun \\ &escape_map/1) + when ((char in 0..0x10FFFF or is_nil(char)) and limit == :infinity) or + (is_integer(limit) and limit >= 0) do + escape(binary, char, limit, [], fun) + end + + defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do + {acc, binary} + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, char]], fun) + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, ?#, ?{]], fun) + end + + defp escape(<>, char, count, acc, fun) do + escaped = if value = fun.(h), do: value, else: escape_char(h) + escape(t, char, decrement(count), [acc | escaped], fun) + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, ?x, to_hex(a), to_hex(b)]], fun) + end + + defp escape(<<>>, _char, _count, acc, _fun) do + {acc, <<>>} + end + + defp escape_char(0), do: [?\\, ?0] + + @escaped_bom :binary.bin_to_list("\\uFEFF") + defp escape_char(65279), do: @escaped_bom + + defp escape_char(char) + when char in 0x20..0x7E + when char in 0xA0..0xD7FF + when char in 0xE000..0xFFFD + when char in 0x10000..0x10FFFF do + <> + end + + defp escape_char(char) when char < 0x100 do + <> = <> + [?\\, ?x, to_hex(a), to_hex(b)] + end + + defp escape_char(char) when char < 0x10000 do + <> = <> + [?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}] + end + + defp escape_char(char) when char < 0x1000000 do + <> = <> + [?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), to_hex(e), to_hex(f), ?}] + end + + defp escape_map(?\a), do: [?\\, ?a] + defp escape_map(?\b), do: [?\\, ?b] + defp escape_map(?\d), do: [?\\, ?d] + defp escape_map(?\e), do: [?\\, ?e] + defp escape_map(?\f), do: [?\\, ?f] + defp escape_map(?\n), do: [?\\, ?n] + defp escape_map(?\r), do: [?\\, ?r] + defp escape_map(?\t), do: [?\\, ?t] + defp escape_map(?\v), do: [?\\, ?v] + defp escape_map(?\\), do: [?\\, ?\\] + defp escape_map(_), do: false + + @compile {:inline, to_hex: 1, decrement: 1} + defp to_hex(c) when c in 0..9, do: ?0 + c + defp to_hex(c) when c in 10..15, do: ?A + c - 10 + + defp decrement(:infinity), do: :infinity + defp decrement(counter), do: counter - 1 +end diff --git a/forge/lib/future/code/typespec.ex b/forge/lib/future/code/typespec.ex new file mode 100644 index 00000000..3b2cb923 --- /dev/null +++ b/forge/lib/future/code/typespec.ex @@ -0,0 +1,433 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/typespec.ex +defmodule Future.Code.Typespec do + @moduledoc false + + @doc """ + Converts a spec clause back to Elixir quoted expression. + """ + @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]} + def spec_to_quoted(name, spec) + + def spec_to_quoted(name, {:type, anno, :fun, [{:type, _, :product, args}, result]}) + when is_atom(name) do + meta = meta(anno) + body = {name, meta, Enum.map(args, &typespec_to_quoted/1)} + + vars = + for type_expr <- args ++ [result], + var <- collect_vars(type_expr), + uniq: true, + do: {var, {:var, meta, nil}} + + spec = {:"::", meta, [body, typespec_to_quoted(result)]} + + if vars == [] do + spec + else + {:when, meta, [spec, vars]} + end + end + + def spec_to_quoted(name, {:type, anno, :fun, []}) when is_atom(name) do + meta = meta(anno) + {:"::", meta, [{name, meta, []}, quote(do: term)]} + end + + def spec_to_quoted(name, {:type, anno, :bounded_fun, [type, constrs]}) when is_atom(name) do + meta = meta(anno) + {:type, _, :fun, [{:type, _, :product, args}, result]} = type + + guards = + for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do + {erl_to_ex_var(var), typespec_to_quoted(type)} + end + + ignore_vars = Keyword.keys(guards) + + vars = + for type_expr <- args ++ [result], + var <- collect_vars(type_expr), + var not in ignore_vars, + uniq: true, + do: {var, {:var, meta, nil}} + + args = for arg <- args, do: typespec_to_quoted(arg) + + when_args = [ + {:"::", meta, [{name, meta, args}, typespec_to_quoted(result)]}, + guards ++ vars + ] + + {:when, meta, when_args} + end + + @doc """ + Converts a type clause back to Elixir AST. + """ + def type_to_quoted(type) + + def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do + fields = for field <- fields, do: typespec_to_quoted(field) + args = for arg <- args, do: typespec_to_quoted(arg) + type = {:{}, [], [record | fields]} + quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type)) + end + + def type_to_quoted({name, type, args}) when is_atom(name) do + args = for arg <- args, do: typespec_to_quoted(arg) + quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type))) + end + + @doc """ + Returns all types available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is the type (`:typep`, `:type` and `:opaque`). + + The module must have a corresponding BEAM file which can be + located by the runtime system. The types will be in the Erlang + Abstract Format. + """ + @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error + def fetch_types(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types + exported_types = List.flatten(exported_types) + + types = + for {:attribute, _, kind, {name, _, args} = type} <- abstract_code, + kind in [:opaque, :type] do + cond do + kind == :opaque -> {:opaque, type} + {name, length(args)} in exported_types -> {:type, type} + true -> {:typep, type} + end + end + + {:ok, types} + + _ -> + :error + end + end + + @doc """ + Returns all specs available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is spec name and arity and the second is the spec. + + The module must have a corresponding BEAM file which can be + located by the runtime system. The types will be in the Erlang + Abstract Format. + """ + @spec fetch_specs(module | binary) :: {:ok, [tuple]} | :error + def fetch_specs(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)} + + :error -> + :error + end + end + + @doc """ + Returns all callbacks available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is spec name and arity and the second is the spec. + + The module must have a corresponding BEAM file + which can be located by the runtime system. The types will be + in the Erlang Abstract Format. + """ + @spec fetch_callbacks(module | binary) :: {:ok, [tuple]} | :error + def fetch_callbacks(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)} + + :error -> + :error + end + end + + defp typespecs_abstract_code(module) do + with {module, binary} <- get_module_and_beam(module), + {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <- + :beam_lib.chunks(binary, [:debug_info]) do + case data do + {:elixir_v1, %{}, specs} -> + # Fast path to avoid translation to Erlang from Elixir. + {:ok, specs} + + _ -> + case backend.debug_info(:erlang_v1, module, data, []) do + {:ok, abstract_code} -> {:ok, abstract_code} + _ -> :error + end + end + else + _ -> :error + end + end + + defp get_module_and_beam(module) when is_atom(module) do + with {^module, beam, _filename} <- :code.get_object_code(module), + info_pairs when is_list(info_pairs) <- :beam_lib.info(beam), + {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do + {module, beam} + else + _ -> :error + end + end + + defp get_module_and_beam(beam) when is_binary(beam) do + case :beam_lib.info(beam) do + [_ | _] = info -> {info[:module], beam} + _ -> :error + end + end + + ## To AST conversion + + defp collect_vars({:ann_type, _anno, args}) when is_list(args) do + [] + end + + defp collect_vars({:type, _anno, _kind, args}) when is_list(args) do + Enum.flat_map(args, &collect_vars/1) + end + + defp collect_vars({:remote_type, _anno, args}) when is_list(args) do + Enum.flat_map(args, &collect_vars/1) + end + + defp collect_vars({:typed_record_field, _anno, type}) do + collect_vars(type) + end + + defp collect_vars({:paren_type, _anno, [type]}) do + collect_vars(type) + end + + defp collect_vars({:var, _anno, var}) do + [erl_to_ex_var(var)] + end + + defp collect_vars(_) do + [] + end + + defp typespec_to_quoted({:user_type, anno, name, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {name, meta(anno), args} + end + + defp typespec_to_quoted({:type, anno, :tuple, :any}) do + {:tuple, meta(anno), []} + end + + defp typespec_to_quoted({:type, anno, :tuple, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {:{}, meta(anno), args} + end + + defp typespec_to_quoted({:type, _anno, :list, [{:type, _, :union, unions} = arg]}) do + case unpack_typespec_kw(unions, []) do + {:ok, ast} -> ast + :error -> [typespec_to_quoted(arg)] + end + end + + defp typespec_to_quoted({:type, anno, :list, []}) do + {:list, meta(anno), []} + end + + defp typespec_to_quoted({:type, _anno, :list, [arg]}) do + [typespec_to_quoted(arg)] + end + + defp typespec_to_quoted({:type, anno, :nonempty_list, []}) do + [{:..., meta(anno), nil}] + end + + defp typespec_to_quoted({:type, anno, :nonempty_list, [arg]}) do + [typespec_to_quoted(arg), {:..., meta(anno), nil}] + end + + defp typespec_to_quoted({:type, anno, :map, :any}) do + {:map, meta(anno), []} + end + + defp typespec_to_quoted({:type, anno, :map, fields}) do + fields = + Enum.map(fields, fn + {:type, _, :map_field_assoc, :any} -> + {{:optional, [], [{:any, [], []}]}, {:any, [], []}} + + {:type, _, :map_field_exact, [{:atom, _, k}, v]} -> + {k, typespec_to_quoted(v)} + + {:type, _, :map_field_exact, [k, v]} -> + {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)} + + {:type, _, :map_field_assoc, [k, v]} -> + {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)} + end) + + case List.keytake(fields, :__struct__, 0) do + {{:__struct__, struct}, fields_pruned} when is_atom(struct) and struct != nil -> + map_pruned = {:%{}, meta(anno), fields_pruned} + {:%, meta(anno), [struct, map_pruned]} + + _ -> + {:%{}, meta(anno), fields} + end + end + + defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do + [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg) + line = meta(anno)[:line] + + case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do + {arg1, 0} -> + quote(line: line, do: <<_::unquote(arg1)>>) + + {0, arg2} -> + quote(line: line, do: <<_::_*unquote(arg2)>>) + + {arg1, arg2} -> + quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>) + end + end + + defp typespec_to_quoted({:type, anno, :union, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, meta(anno), [arg, expr]} end) + end + + defp typespec_to_quoted({:type, anno, :fun, [{:type, _, :product, args}, result]}) do + args = for arg <- args, do: typespec_to_quoted(arg) + [{:->, meta(anno), [args, typespec_to_quoted(result)]}] + end + + defp typespec_to_quoted({:type, anno, :fun, [args, result]}) do + [{:->, meta(anno), [[typespec_to_quoted(args)], typespec_to_quoted(result)]}] + end + + defp typespec_to_quoted({:type, anno, :fun, []}) do + typespec_to_quoted({:type, anno, :fun, [{:type, anno, :any}, {:type, anno, :any, []}]}) + end + + defp typespec_to_quoted({:type, anno, :range, [left, right]}) do + {:.., meta(anno), [typespec_to_quoted(left), typespec_to_quoted(right)]} + end + + defp typespec_to_quoted({:type, _anno, nil, []}) do + [] + end + + defp typespec_to_quoted({:type, anno, name, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {name, meta(anno), args} + end + + defp typespec_to_quoted({:var, anno, var}) do + {erl_to_ex_var(var), meta(anno), nil} + end + + defp typespec_to_quoted({:op, anno, op, arg}) do + {op, meta(anno), [typespec_to_quoted(arg)]} + end + + defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do + remote_type(anno, mod, name, args) + end + + defp typespec_to_quoted({:ann_type, anno, [var, type]}) do + {:"::", meta(anno), [typespec_to_quoted(var), typespec_to_quoted(type)]} + end + + defp typespec_to_quoted( + {:typed_record_field, {:record_field, anno1, {:atom, anno2, name}}, type} + ) do + typespec_to_quoted({:ann_type, anno1, [{:var, anno2, name}, type]}) + end + + defp typespec_to_quoted({:type, _, :any}) do + quote(do: ...) + end + + defp typespec_to_quoted({:paren_type, _, [type]}) do + typespec_to_quoted(type) + end + + defp typespec_to_quoted({type, _anno, atom}) when is_atom(type) do + atom + end + + defp typespec_to_quoted(other), do: other + + ## Helpers + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do + typespec_to_quoted({:type, anno, :charlist, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do + typespec_to_quoted({:type, anno, :nonempty_charlist, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :struct}, []) do + typespec_to_quoted({:type, anno, :struct, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do + typespec_to_quoted({:type, anno, :as_boolean, [arg]}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do + typespec_to_quoted({:type, anno, :keyword, args}) + end + + defp remote_type(anno, mod, name, args) do + args = for arg <- args, do: typespec_to_quoted(arg) + dot = {:., meta(anno), [typespec_to_quoted(mod), typespec_to_quoted(name)]} + {dot, meta(anno), args} + end + + defp erl_to_ex_var(var) do + case Atom.to_string(var) do + <<"_", c::utf8, rest::binary>> -> + String.to_atom("_#{String.downcase(<>)}#{rest}") + + <> -> + String.to_atom("#{String.downcase(<>)}#{rest}") + end + end + + defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do + unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc]) + end + + defp unpack_typespec_kw([], acc) do + {:ok, Enum.reverse(acc)} + end + + defp unpack_typespec_kw(_, _acc) do + :error + end + + defp meta(anno) do + case :erl_anno.location(anno) do + {line, column} -> + [line: line, column: column] + + line when is_integer(line) -> + [line: line] + end + end +end diff --git a/forge/lib/future/macro.ex b/forge/lib/future/macro.ex new file mode 100644 index 00000000..29f83b43 --- /dev/null +++ b/forge/lib/future/macro.ex @@ -0,0 +1,95 @@ +# Copied some code from https://github.com/elixir-lang/elixir/blob/44c18a3/lib/elixir/lib/macro.ex#L440 +# only copied the `path/2` +import Kernel, except: [to_string: 1] + +defmodule Future.Macro do + @doc """ + Returns the path to the node in `ast` which `fun` returns `true`. + + The path is a list, starting with the node in which `fun` returns + true, followed by all of its parents. + + Computing the path can be an efficient operation when you want + to find a particular node in the AST within its context and then + assert something about it. + + ## Examples + + iex> Macro.path(quote(do: [1, 2, 3]), & &1 == 3) + [3, [1, 2, 3]] + + iex> Macro.path(quote(do: Foo.bar(3)), & &1 == 3) + [3, quote(do: Foo.bar(3))] + + iex> Macro.path(quote(do: %{foo: [bar: :baz]}), & &1 == :baz) + [ + :baz, + {:bar, :baz}, + [bar: :baz], + {:foo, [bar: :baz]}, + {:%{}, [], [foo: [bar: :baz]]} + ] + + """ + @doc since: "1.14.0" + def path(ast, fun) when is_function(fun, 1) do + path(ast, [], fun) + end + + defp path({form, _, args} = ast, acc, fun) when is_atom(form) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path_args(args, acc, fun) + end + end + + defp path({form, _meta, args} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path(form, acc, fun) || path_args(args, acc, fun) + end + end + + defp path({left, right} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path(left, acc, fun) || path(right, acc, fun) + end + end + + defp path(list, acc, fun) when is_list(list) do + acc = [list | acc] + + if fun.(list) do + acc + else + path_list(list, acc, fun) + end + end + + defp path(ast, acc, fun) do + if fun.(ast) do + [ast | acc] + end + end + + defp path_args(atom, _acc, _fun) when is_atom(atom), do: nil + defp path_args(list, acc, fun) when is_list(list), do: path_list(list, acc, fun) + + defp path_list([], _acc, _fun) do + nil + end + + defp path_list([arg | args], acc, fun) do + path(arg, acc, fun) || path_list(args, acc, fun) + end +end diff --git a/forge/lib/mix/tasks/hooks.ex b/forge/lib/mix/tasks/hooks.ex new file mode 100644 index 00000000..e24c653c --- /dev/null +++ b/forge/lib/mix/tasks/hooks.ex @@ -0,0 +1,39 @@ +defmodule Mix.Tasks.Hooks do + def run(_) do + sources = + [File.cwd!(), "hooks", "**"] + |> Path.join() + |> Path.wildcard() + + sources_count = length(sources) + hook_text = pluralize(sources_count, "hook", "hooks") + Mix.Shell.IO.info("Copying #{sources_count} #{hook_text}") + dest_dir = Path.join([File.cwd!(), ".git", "hooks"]) + + for source <- sources, + dest_path = Path.join(dest_dir, Path.basename(source)) do + if File.exists?(dest_path) do + File.rm(dest_path) + end + + message = + case File.cp(source, dest_path) do + :ok -> + " #{Path.basename(source)}: ✅" + + {:error, reason} -> + " #{Path.basename(source)} ❌ #{inspect(reason)}" + end + + Mix.Shell.IO.info(message) + end + end + + defp pluralize(count, singular, plural) do + if count == 1 do + singular + else + plural + end + end +end diff --git a/forge/mix.exs b/forge/mix.exs new file mode 100644 index 00000000..dcc3524d --- /dev/null +++ b/forge/mix.exs @@ -0,0 +1,34 @@ +defmodule Forge.MixProject do + use Mix.Project + + def project do + [ + app: :forge, + version: "0.1.0", + elixir: "~> 1.17", + compilers: [:yecc] ++ Mix.compilers(), + start_permanent: Mix.env() == :prod, + deps: deps() + ] + end + + # Run "mix help compile.app" to learn about applications. + def application do + [ + extra_applications: [:logger] + ] + end + + # Run "mix help deps" to learn about dependencies. + defp deps do + [ + {:sourceror, "~> 1.0"}, + {:snowflake, "~> 1.0"}, + {:elixir_sense, github: "elixir-lsp/elixir_sense"}, + {:namespace, path: "../namespace/"} + + # {:dep_from_hexpm, "~> 0.3.0"}, + # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"} + ] + end +end diff --git a/forge/mix.lock b/forge/mix.lock new file mode 100644 index 00000000..90f0d35c --- /dev/null +++ b/forge/mix.lock @@ -0,0 +1,5 @@ +%{ + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "706c498be371882366151b588e5cd13c9c08404c", []}, + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, +} diff --git a/forge/src/future_elixir.erl b/forge/src/future_elixir.erl new file mode 100644 index 00000000..4580963f --- /dev/null +++ b/forge/src/future_elixir.erl @@ -0,0 +1,542 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir.erl +%% Main entry point for Elixir functions. All of those functions are +%% private to the Elixir compiler and reserved to be used by Elixir only. +-module(future_elixir). +-behaviour(application). +-export([start_cli/0, start/0]). +-export([start/2, stop/1, config_change/3]). +-export([ + string_to_tokens/5, tokens_to_quoted/3, 'string_to_quoted!'/5, + env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_quoted/3, + eval_quoted/4, eval_local_handler/2, eval_external_handler/3, + format_token_error/1 +]). +-include("future_elixir.hrl"). +-define(system, 'Elixir.System'). +-define(elixir_eval_env, {elixir, eval_env}). + +%% Top level types +%% TODO: Remove char_list type on v2.0 +-export_type([charlist/0, char_list/0, nonempty_charlist/0, struct/0, as_boolean/1, keyword/0, keyword/1]). +-type charlist() :: string(). +-type char_list() :: string(). +-type nonempty_charlist() :: nonempty_string(). +-type as_boolean(T) :: T. +-type keyword() :: [{atom(), any()}]. +-type keyword(T) :: [{atom(), T}]. +-type struct() :: #{'__struct__' := atom(), atom() => any()}. + +%% OTP Application API +%% TODO: Remove Erlang/OTP 26+ checks + +load_paths(OTP, Paths) when OTP >= 26 -> code:add_pathsa(Paths, cache); +load_paths(_OTP, Paths) -> code:add_pathsa(Paths). + +start(_Type, _Args) -> + OTP = parse_otp_release(), + preload_common_modules(), + set_stdio_and_stderr_to_binary_and_maybe_utf8(OTP), + check_file_encoding(file:native_name_encoding()), + + case init:get_argument(elixir_root) of + {ok, [[Root]]} -> + load_paths(OTP, [ + Root ++ "/eex/ebin", + Root ++ "/ex_unit/ebin", + Root ++ "/iex/ebin", + Root ++ "/logger/ebin", + Root ++ "/mix/ebin", + Root ++ "/elixir/ebin" + ]); + _ -> + ok + end, + + case application:get_env(elixir, check_endianness, true) of + true -> check_endianness(); + false -> ok + end, + + case application:get_env(elixir, ansi_enabled) of + {ok, _} -> ok; + undefined -> + %% Remove prim_tty module check as well as checks from scripts on Erlang/OTP 26 + ANSIEnabled = erlang:module_loaded(prim_tty) andalso (prim_tty:isatty(stdout) == true), + application:set_env(elixir, ansi_enabled, ANSIEnabled) + end, + + Tokenizer = case code:ensure_loaded('Elixir.String.Tokenizer') of + {module, Mod} -> Mod; + _ -> future_elixir_tokenizer + end, + + URIConfig = [ + {{uri, <<"ftp">>}, 21}, + {{uri, <<"sftp">>}, 22}, + {{uri, <<"tftp">>}, 69}, + {{uri, <<"http">>}, 80}, + {{uri, <<"https">>}, 443}, + {{uri, <<"ldap">>}, 389}, + {{uri, <<"ws">>}, 80}, + {{uri, <<"wss">>}, 443} + ], + + Config = [ + %% ARGV options + {at_exit, []}, + {argv, []}, + {no_halt, false}, + + %% Compiler options + {docs, true}, + {ignore_already_consolidated, false}, + {ignore_module_conflict, false}, + {on_undefined_variable, raise}, + {parser_options, [{columns, true}]}, + {debug_info, true}, + {warnings_as_errors, false}, + {relative_paths, true}, + {no_warn_undefined, []}, + {tracers, []} + | URIConfig + ], + + elixir_config:static(#{bootstrap => false, identifier_tokenizer => Tokenizer}), + Tab = elixir_config:new(Config), + + case elixir_sup:start_link() of + {ok, Sup} -> + {ok, Sup, Tab}; + {error, _Reason} = Error -> + elixir_config:delete(Tab), + Error + end. + +stop(Tab) -> + elixir_config:delete(Tab). + +config_change(_Changed, _New, _Remove) -> + ok. + +set_stdio_and_stderr_to_binary_and_maybe_utf8(OTP) when OTP >= 26 -> + ok = io:setopts(standard_io, [binary]), + ok; +set_stdio_and_stderr_to_binary_and_maybe_utf8(_OTP) -> + Opts = + case init:get_argument(noshell) of + {ok, _} -> [binary, {encoding, utf8}]; + error -> [binary] + end, + ok = io:setopts(standard_io, Opts), + ok = io:setopts(standard_error, [{encoding, utf8}]), + ok. + +preload_common_modules() -> + %% We attempt to load those modules here so throughout + %% the codebase we can avoid code:ensure_loaded/1 checks. + _ = code:ensure_loaded('Elixir.Kernel'), + _ = code:ensure_loaded('Elixir.Macro.Env'), + ok. + +parse_otp_release() -> + %% Whenever we change this check, we should also change Makefile. + case string:to_integer(erlang:system_info(otp_release)) of + {Num, _} when Num >= 25 -> + Num; + _ -> + io:format(standard_error, "ERROR! Unsupported Erlang/OTP version, expected Erlang/OTP 25+~n", []), + erlang:halt(1) + end. + +check_endianness() -> + case code:ensure_loaded(?system) of + {module, ?system} -> + Endianness = ?system:endianness(), + case ?system:compiled_endianness() of + Endianness -> + ok; + _ -> + io:format(standard_error, + "warning: Elixir is running in a system with a different endianness than the one its " + "source code was compiled in. Please make sure Elixir and all source files were compiled " + "in a machine with the same endianness as the current one: ~ts~n", [Endianness]) + end; + {error, _} -> + ok + end. + +check_file_encoding(Encoding) -> + case Encoding of + latin1 -> + io:format(standard_error, + "warning: the VM is running with native name encoding of latin1 which may cause " + "Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 " + "(which can be verified by running \"locale\" in your shell) or set the " + "ELIXIR_ERL_OPTIONS=\"+fnu\" environment variable~n", []); + _ -> + ok + end. + +%% Boot and process given options. Invoked by Elixir's script. +%% TODO: Delete prim_tty branches on Erlang/OTP 26. + +start() -> + case code:ensure_loaded(prim_tty) of + {module, _} -> + user_drv:start(#{initial_shell => iex:shell()}); + {error, _} -> + case init:get_argument(elixir_root) of + {ok, [[Root]]} -> code:add_patha(Root ++ "/iex/ebin"); + _ -> ok + end, + 'Elixir.IEx.CLI':deprecated() + end. + +start_cli() -> + {ok, _} = application:ensure_all_started(elixir), + + %% We start the Logger so tools that depend on Elixir + %% always have the Logger directly accessible. However + %% Logger is not a dependency of the Elixir application, + %% which means releases that want to use Logger must + %% always list it as part of its applications. + _ = case code:ensure_loaded('Elixir.Logger') of + {module, _} -> application:start(logger); + {error, _} -> ok + end, + + 'Elixir.Kernel.CLI':main(init:get_plain_arguments()). + +%% EVAL HOOKS + +env_for_eval(#{lexical_tracker := Pid} = Env) -> + NewEnv = Env#{ + context := nil, + context_modules := [], + macro_aliases := [], + versioned_vars := #{} + }, + + case is_pid(Pid) of + true -> + case is_process_alive(Pid) of + true -> + NewEnv; + false -> + 'Elixir.IO':warn( + <<"an __ENV__ with outdated compilation information was given to eval, " + "call Macro.Env.prune_compile_info/1 to prune it">> + ), + NewEnv#{lexical_tracker := nil, tracers := []} + end; + false -> + NewEnv#{tracers := []} + end; +env_for_eval(Opts) when is_list(Opts) -> + Env = elixir_env:new(), + + Line = case lists:keyfind(line, 1, Opts) of + {line, LineOpt} when is_integer(LineOpt) -> LineOpt; + false -> ?key(Env, line) + end, + + File = case lists:keyfind(file, 1, Opts) of + {file, FileOpt} when is_binary(FileOpt) -> FileOpt; + false -> ?key(Env, file) + end, + + Module = case lists:keyfind(module, 1, Opts) of + {module, ModuleOpt} when is_atom(ModuleOpt) -> ModuleOpt; + false -> nil + end, + + FA = case lists:keyfind(function, 1, Opts) of + {function, {Function, Arity}} when is_atom(Function), is_integer(Arity) -> {Function, Arity}; + {function, nil} -> nil; + false -> nil + end, + + TempTracers = case lists:keyfind(tracers, 1, Opts) of + {tracers, TracersOpt} when is_list(TracersOpt) -> TracersOpt; + false -> [] + end, + + Aliases = case lists:keyfind(aliases, 1, Opts) of + {aliases, AliasesOpt} when is_list(AliasesOpt) -> + 'Elixir.IO':warn(<<":aliases option in eval is deprecated">>), + AliasesOpt; + false -> + ?key(Env, aliases) + end, + + Requires = case lists:keyfind(requires, 1, Opts) of + {requires, RequiresOpt} when is_list(RequiresOpt) -> + 'Elixir.IO':warn(<<":requires option in eval is deprecated">>), + ordsets:from_list(RequiresOpt); + false -> + ?key(Env, requires) + end, + + Functions = case lists:keyfind(functions, 1, Opts) of + {functions, FunctionsOpt} when is_list(FunctionsOpt) -> + 'Elixir.IO':warn(<<":functions option in eval is deprecated">>), + FunctionsOpt; + false -> + ?key(Env, functions) + end, + + Macros = case lists:keyfind(macros, 1, Opts) of + {macros, MacrosOpt} when is_list(MacrosOpt) -> + 'Elixir.IO':warn(<<":macros option in eval is deprecated">>), + MacrosOpt; + false -> + ?key(Env, macros) + end, + + %% If there is a dead PID or lexical tracker is nil, + %% we assume the tracers also cannot be (re)used. + {LexicalTracker, Tracers} = case lists:keyfind(lexical_tracker, 1, Opts) of + {lexical_tracker, Pid} when is_pid(Pid) -> + 'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>), + case is_process_alive(Pid) of + true -> {Pid, TempTracers}; + false -> {nil, []} + end; + {lexical_tracker, nil} -> + 'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>), + {nil, []}; + false -> + {nil, TempTracers} + end, + + Env#{ + file := File, module := Module, function := FA, tracers := Tracers, + macros := Macros, functions := Functions, lexical_tracker := LexicalTracker, + requires := Requires, aliases := Aliases, line := Line + }. + +%% Quoted evaluation + +eval_quoted(Tree, Binding, E) -> + eval_quoted(Tree, Binding, E, []). +eval_quoted(Tree, Binding, #{line := Line} = E, Opts) -> + eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E, Opts). + +eval_forms(Tree, Binding, OrigE) -> + eval_forms(Tree, Binding, OrigE, []). +eval_forms(Tree, Binding, OrigE, Opts) -> + Prune = proplists:get_value(prune_binding, Opts, false), + {ExVars, ErlVars, ErlBinding} = elixir_erl_var:load_binding(Binding, Prune), + E = elixir_env:with_vars(OrigE, ExVars), + ExS = elixir_env:env_to_ex(E), + ErlS = elixir_erl_var:from_env(E, ErlVars), + {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E), + + case Erl of + {Literal, _, Value} when Literal == atom; Literal == float; Literal == integer -> + if + Prune -> {Value, [], NewE#{versioned_vars := #{}}}; + true -> {Value, Binding, NewE} + end; + + _ -> + Exprs = + case Erl of + {block, _, BlockExprs} -> BlockExprs; + _ -> [Erl] + end, + + %% We use remote names so eval works across Elixir versions. + LocalHandler = {value, fun ?MODULE:eval_local_handler/2}, + ExternalHandler = {value, fun ?MODULE:eval_external_handler/3}, + + {value, Value, NewBinding} = + try + %% ?elixir_eval_env is used by the external handler. + %% + %% The reason why we use the process dictionary to pass the environment + %% is because we want to avoid passing closures to erl_eval, as that + %% would effectively tie the eval code to the Elixir version and it is + %% best if it depends solely on Erlang/OTP. + %% + %% The downside is that functions that escape the eval context will no + %% longer have the original environment they came from. + erlang:put(?elixir_eval_env, NewE), + erl_eval:exprs(Exprs, ErlBinding, LocalHandler, ExternalHandler) + after + erlang:erase(?elixir_eval_env) + end, + + PruneBefore = if Prune -> length(Binding); true -> -1 end, + + {DumpedBinding, DumpedVars} = + elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore), + + {Value, DumpedBinding, NewE#{versioned_vars := DumpedVars}} + end. + +eval_local_handler(FunName, Args) -> + {current_stacktrace, Stack} = erlang:process_info(self(), current_stacktrace), + Opts = [{module, nil}, {function, FunName}, {arity, length(Args)}, {reason, 'undefined local'}], + Exception = 'Elixir.UndefinedFunctionError':exception(Opts), + erlang:raise(error, Exception, Stack). + +eval_external_handler(Ann, FunOrModFun, Args) -> + try + case FunOrModFun of + {Mod, Fun} -> apply(Mod, Fun, Args); + Fun -> apply(Fun, Args) + end + catch + Kind:Reason:Stacktrace -> + %% Take everything up to the Elixir module + Pruned = + lists:takewhile(fun + ({elixir,_,_,_}) -> false; + (_) -> true + end, Stacktrace), + + Caller = + lists:dropwhile(fun + ({elixir,_,_,_}) -> false; + (_) -> true + end, Stacktrace), + + %% Now we prune any shared code path from erl_eval + {current_stacktrace, Current} = + erlang:process_info(self(), current_stacktrace), + + %% We need to make sure that we don't generate more + %% frames than supported. So we do our best to drop + %% from the Caller, but if the caller has no frames, + %% we need to drop from Pruned. + {DroppedCaller, ToDrop} = + case Caller of + [] -> {[], true}; + _ -> {lists:droplast(Caller), false} + end, + + Reversed = drop_common(lists:reverse(Current), lists:reverse(Pruned), ToDrop), + + %% Add file+line information at the bottom + Bottom = + case erlang:get(?elixir_eval_env) of + #{file := File} -> + [{elixir_eval, '__FILE__', 1, + [{file, elixir_utils:characters_to_list(File)}, {line, erl_anno:line(Ann)}]}]; + + _ -> + [] + end, + + Custom = lists:reverse(Bottom ++ Reversed, DroppedCaller), + erlang:raise(Kind, Reason, Custom) + end. + +%% We need to check if we have dropped any frames. +%% If we have not dropped frames, then we need to drop one +%% at the end so we can put the elixir_eval frame in. If +%% we have more traces then depth, Erlang would discard +%% the whole stacktrace. +drop_common([H | T1], [H | T2], _ToDrop) -> drop_common(T1, T2, false); +drop_common([_ | T1], T2, ToDrop) -> drop_common(T1, T2, ToDrop); +drop_common([], [{?MODULE, _, _, _} | T2], _ToDrop) -> T2; +drop_common([], [_ | T2], true) -> T2; +drop_common([], T2, _) -> T2. + +%% Converts a quoted expression to Erlang abstract format + +quoted_to_erl(Quoted, E) -> + {_, ErlS} = elixir_erl_var:from_env(E), + ExS = elixir_env:env_to_ex(E), + quoted_to_erl(Quoted, ErlS, ExS, E). + +quoted_to_erl(Quoted, ErlS, ExS, Env) -> + {Expanded, NewExS, NewEnv} = + elixir_expand:expand(Quoted, ExS, Env), + {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), ErlS), + {Erl, NewErlS, NewExS, NewEnv}. + +%% Converts a given string (charlist) into quote expression + +string_to_tokens(String, StartLine, StartColumn, File, Opts) when is_integer(StartLine), is_binary(File) -> + case future_elixir_tokenizer:tokenize(String, StartLine, StartColumn, Opts) of + {ok, _Line, _Column, [], Tokens, Terminators} -> + {ok, lists:reverse(Tokens, Terminators)}; + {ok, _Line, _Column, Warnings, Tokens, Terminators} -> + (lists:keyfind(emit_warnings, 1, Opts) /= {emit_warnings, false}) andalso + [future_elixir_errors:erl_warn(L, File, M) || {L, M} <- lists:reverse(Warnings)], + {ok, lists:reverse(Tokens, Terminators)}; + {error, Info, _Rest, _Warnings, _SoFar} -> + {error, format_token_error(Info)} + end. + +format_token_error({Location, {ErrorPrefix, ErrorSuffix}, Token}) -> + {Location, {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}; +format_token_error({Location, Error, Token}) -> + {Location, to_binary(Error), to_binary(Token)}. + +tokens_to_quoted(Tokens, WarningFile, Opts) -> + handle_parsing_opts(WarningFile, Opts), + + try future_elixir_parser:parse(Tokens) of + {ok, Forms} -> + {ok, Forms}; + {error, {Line, _, [{ErrorPrefix, ErrorSuffix}, Token]}} -> + {error, {parser_location(Line), {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}}; + {error, {Line, _, [Error, Token]}} -> + {error, {parser_location(Line), to_binary(Error), to_binary(Token)}} + after + erase(elixir_parser_warning_file), + erase(elixir_parser_columns), + erase(elixir_token_metadata), + erase(elixir_literal_encoder) + end. + +parser_location({Line, Column, _}) -> + [{line, Line}, {column, Column}]; +parser_location(Meta) -> + Line = + case lists:keyfind(line, 1, Meta) of + {line, L} -> L; + false -> 0 + end, + + case lists:keyfind(column, 1, Meta) of + {column, C} -> [{line, Line}, {column, C}]; + false -> [{line, Line}] + end. + +'string_to_quoted!'(String, StartLine, StartColumn, File, Opts) -> + case string_to_tokens(String, StartLine, StartColumn, File, Opts) of + {ok, Tokens} -> + case tokens_to_quoted(Tokens, File, Opts) of + {ok, Forms} -> + Forms; + {error, {Meta, Error, Token}} -> + future_elixir_errors:parse_error(Meta, File, Error, Token, {String, StartLine, StartColumn}) + end; + {error, {Meta, Error, Token}} -> + future_elixir_errors:parse_error(Meta, File, Error, Token, {String, StartLine, StartColumn}) + end. + +to_binary(List) when is_list(List) -> elixir_utils:characters_to_binary(List); +to_binary(Atom) when is_atom(Atom) -> atom_to_binary(Atom). + +handle_parsing_opts(File, Opts) -> + WarningFile = + case lists:keyfind(emit_warnings, 1, Opts) of + {emit_warnings, false} -> nil; + _ -> File + end, + LiteralEncoder = + case lists:keyfind(literal_encoder, 1, Opts) of + {literal_encoder, Fun} -> Fun; + false -> false + end, + TokenMetadata = lists:keyfind(token_metadata, 1, Opts) == {token_metadata, true}, + Columns = lists:keyfind(columns, 1, Opts) == {columns, true}, + put(elixir_parser_warning_file, WarningFile), + put(elixir_parser_columns, Columns), + put(elixir_token_metadata, TokenMetadata), + put(elixir_literal_encoder, LiteralEncoder). diff --git a/forge/src/future_elixir.hrl b/forge/src/future_elixir.hrl new file mode 100644 index 00000000..66635295 --- /dev/null +++ b/forge/src/future_elixir.hrl @@ -0,0 +1,43 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir.hrl +-define(key(M, K), maps:get(K, M)). +-define(ann(Meta), elixir_erl:get_ann(Meta)). +-define(line(Meta), elixir_utils:get_line(Meta)). +-define(generated(Meta), elixir_utils:generated(Meta)). +-define(var_context, ?MODULE). +-define(remote(Ann, Module, Function, Args), {call, Ann, {remote, Ann, {atom, Ann, Module}, {atom, Ann, Function}}, Args}). + +-record(elixir_ex, { + caller=false, %% stores if __CALLER__ is allowed + %% TODO: Remove warn and everywhere it is set in v2.0 + prematch=raise, %% {Read, Counter, {bitsize, Original} | none} | warn | raise | pin + stacktrace=false, %% stores if __STACKTRACE__ is allowed + unused={#{}, 0}, %% a map of unused vars and a version counter for vars + runtime_modules=[], %% a list of modules defined in functions (runtime) + vars={#{}, false} %% a tuple with maps of read and optional write current vars +}). + +-record(elixir_erl, { + context=nil, %% can be match, guards or nil + extra=nil, %% extra information about the context, like pin_guard and map_key + caller=false, %% when true, it means caller was invoked + var_names=#{}, %% maps of defined variables and their alias + extra_guards=[], %% extra guards from args expansion + counter=#{}, %% a map counting the variables defined + expand_captures=false, %% a boolean to control if captures should be expanded + stacktrace=nil %% holds information about the stacktrace variable +}). + +-record(elixir_tokenizer, { + terminators=[], + unescape=true, + cursor_completion=false, + existing_atoms_only=false, + static_atoms_encoder=nil, + preserve_comments=nil, + identifier_tokenizer=elixir_tokenizer, + ascii_identifiers_only=true, + indentation=0, + column=1, + mismatch_hints=[], + warnings=[] +}). diff --git a/forge/src/future_elixir_errors.erl b/forge/src/future_elixir_errors.erl new file mode 100644 index 00000000..af0aadc7 --- /dev/null +++ b/forge/src/future_elixir_errors.erl @@ -0,0 +1,526 @@ +%% Copied from https://raw.githubusercontent.com/elixir-lang/elixir/31f5f126a6df0ceb4fe93d01545255380b74f4e8/lib/elixir/src/elixir_errors.erl +%% A bunch of helpers to help to deal with errors in Elixir source code. +%% This is not exposed in the Elixir language. +%% +%% Note that this is also called by the Erlang backend, so we also support +%% the line number to be none (as it may happen in some erlang errors). +-module(future_elixir_errors). +-export([compile_error/1, compile_error/3, parse_error/5]). +-export([function_error/4, module_error/4, file_error/4]). +-export([format_snippet/6]). +-export([erl_warn/3, file_warn/4]). +-export([prefix/1]). +-export([print_diagnostics/1, print_diagnostic/2, emit_diagnostic/6]). +-export([print_warning/3]). +-include("future_elixir.hrl"). +-type location() :: non_neg_integer() | {non_neg_integer(), non_neg_integer()}. + +%% Diagnostic API + +%% TODO: Remove me on Elixir v2.0. +%% Called by deprecated Kernel.ParallelCompiler.print_warning. +print_warning(Position, File, Message) -> + Output = format_snippet(warning, Position, File, Message, nil, #{}), + io:put_chars(standard_error, [Output, $\n, $\n]). + +read_snippet(nil, _Position) -> + nil; +read_snippet(<<"nofile">>, _Position) -> + nil; +read_snippet(File, Position) -> + LineNumber = extract_line(Position), + get_file_line(File, LineNumber). + +get_file_line(File, LineNumber) when is_integer(LineNumber), LineNumber > 0 -> + case file:open(File, [read, binary]) of + {ok, IoDevice} -> + Line = traverse_file_line(IoDevice, LineNumber), + ok = file:close(IoDevice), + Line; + {error, _} -> + nil + end; +get_file_line(_, _) -> nil. + +traverse_file_line(IoDevice, 1) -> + case file:read_line(IoDevice) of + {ok, Line} -> binary:replace(Line, <<"\n">>, <<>>); + _ -> nil + end; +traverse_file_line(IoDevice, N) -> + file:read_line(IoDevice), + traverse_file_line(IoDevice, N - 1). + +%% Used by Module.ParallelChecker. +print_diagnostics([Diagnostic | Others]) -> + #{file := File, position := Position, message := Message} = Diagnostic, + Snippet = read_snippet(File, Position), + Formatted = format_snippet(warning, Position, File, Message, Snippet, Diagnostic), + LineNumber = extract_line(Position), + LineDigits = get_line_number_digits(LineNumber, 1), + Padding = case Snippet of + nil -> 0; + _ -> max(4, LineDigits + 2) + end, + Locations = [["\n", n_spaces(Padding), "└─ ", 'Elixir.Exception':format_stacktrace_entry(ES)] || #{stacktrace := [ES]} <- Others], + io:put_chars(standard_error, [Formatted, Locations, $\n, $\n]). + +print_diagnostic(#{severity := S, message := M, position := P, file := F} = Diagnostic, ReadSnippet) -> + Snippet = + case ReadSnippet of + true -> read_snippet(F, P); + false -> nil + end, + + Output = format_snippet(S, P, F, M, Snippet, Diagnostic), + + MaybeStack = + case (F /= nil) orelse elixir_config:is_bootstrap() of + true -> []; + false -> [["\n ", 'Elixir.Exception':format_stacktrace_entry(E)] || E <- ?key(Diagnostic, stacktrace)] + end, + + io:put_chars(standard_error, [Output, MaybeStack, $\n, $\n]), + Diagnostic. + +emit_diagnostic(Severity, Position, File, Message, Stacktrace, Options) -> + ReadSnippet = proplists:get_value(read_snippet, Options, false), + + Span = case lists:keyfind(span, 1, Options) of + {span, {EndLine, EndCol}} -> {EndLine, EndCol}; + _ -> nil + end, + + Diagnostic = #{ + severity => Severity, + source => File, + file => File, + position => Position, + message => unicode:characters_to_binary(Message), + stacktrace => Stacktrace, + span => Span + }, + + case get(elixir_code_diagnostics) of + undefined -> + case get(elixir_compiler_info) of + undefined -> print_diagnostic(Diagnostic, ReadSnippet); + {CompilerPid, _} -> CompilerPid ! {diagnostic, Diagnostic, ReadSnippet} + end; + + {Tail, true} -> + put(elixir_code_diagnostics, {[print_diagnostic(Diagnostic, ReadSnippet) | Tail], true}); + + {Tail, false} -> + put(elixir_code_diagnostics, {[Diagnostic | Tail], false}) + end, + + ok. + +extract_line({L, _}) -> L; +extract_line(L) -> L. + +extract_column({_, C}) -> C; +extract_column(_) -> nil. + +%% Format snippets +%% "Snippet" here refers to the source code line where the diagnostic/error occurred + +format_snippet(Severity, _Position, nil, Message, nil, _Diagnostic) -> + Formatted = [prefix(Severity), " ", Message], + unicode:characters_to_binary(Formatted); + +format_snippet(Severity, Position, File, Message, nil, Diagnostic) -> + Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])), + + Formatted = io_lib:format( + "~ts ~ts\n" + "└─ ~ts", + [prefix(Severity), Message, Location] + ), + + unicode:characters_to_binary(Formatted); + +format_snippet(Severity, Position, File, Message, Snippet, Diagnostic) -> + Column = extract_column(Position), + LineNumber = extract_line(Position), + LineDigits = get_line_number_digits(LineNumber, 1), + Spacing = n_spaces(max(2, LineDigits) + 1), + LineNumberSpacing = if LineDigits =:= 1 -> 1; true -> 0 end, + {FormattedLine, ColumnsTrimmed} = format_line(Snippet), + Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])), + MessageDetail = format_detail(Diagnostic, Message), + + Highlight = + case Column of + nil -> + highlight_below_line(FormattedLine, Severity); + _ -> + Length = calculate_span_length({LineNumber, Column}, Diagnostic), + highlight_at_position(Column - ColumnsTrimmed, Severity, Length) + end, + + Formatted = io_lib:format( + " ~ts~ts ~ts\n" + " ~ts│\n" + " ~ts~p │ ~ts\n" + " ~ts│ ~ts\n" + " ~ts│\n" + " ~ts└─ ~ts", + [ + Spacing, prefix(Severity), format_message(MessageDetail, LineDigits, 2 + LineNumberSpacing), + Spacing, + n_spaces(LineNumberSpacing), LineNumber, FormattedLine, + Spacing, Highlight, + Spacing, + Spacing, Location + ]), + + unicode:characters_to_binary(Formatted). + +format_detail(#{details := #{typing_traces := _}}, Message) -> [Message | "\ntyping violation found at:"]; +format_detail(_, Message) -> Message. + +calculate_span_length({StartLine, StartCol}, #{span := {StartLine, EndCol}}) -> EndCol - StartCol; +calculate_span_length({StartLine, _}, #{span := {EndLine, _}}) when EndLine > StartLine -> 1; +calculate_span_length({_, _}, #{}) -> 1. + +format_line(Line) -> + case trim_line(Line, 0) of + {Trimmed, SpacesMatched} when SpacesMatched >= 27 -> + ColumnsTrimmed = SpacesMatched - 22, + {["...", n_spaces(19), Trimmed], ColumnsTrimmed}; + + {_, _} -> + {Line, 0} + end. + +trim_line(<<$\s, Rest/binary>>, Count) -> trim_line(Rest, Count + 1); +trim_line(<<$\t, Rest/binary>>, Count) -> trim_line(Rest, Count + 8); +trim_line(Rest, Count) -> {Rest, Count}. + +format_message(Message, NDigits, PaddingSize) -> + Padding = list_to_binary([$\n, n_spaces(NDigits + PaddingSize)]), + Bin = unicode:characters_to_binary(Message), + pad_line(binary:split(Bin, <<"\n">>, [global]), Padding). + +pad_line([Last], _Padding) -> [Last]; +pad_line([First, <<"">> | Rest], Padding) -> [First, "\n" | pad_line([<<"">> | Rest], Padding)]; +pad_line([First | Rest], Padding) -> [First, Padding | pad_line(Rest, Padding)]. + +highlight_at_position(Column, Severity, Length) -> + Spacing = n_spaces(max(Column - 1, 0)), + case Severity of + warning -> highlight([Spacing, lists:duplicate(Length, $~)], warning); + error -> highlight([Spacing, lists:duplicate(Length, $^)], error) + end. + +highlight_below_line(Line, Severity) -> + % Don't highlight leading whitespaces in line + {_, SpacesMatched} = trim_line(Line, 0), + + Length = string:length(Line), + Highlight = case Severity of + warning -> highlight(lists:duplicate(Length - SpacesMatched, $~), warning); + error -> highlight(lists:duplicate(Length - SpacesMatched, $^), error) + end, + + [n_spaces(SpacesMatched), Highlight]. + +get_line_number_digits(Number, Acc) when Number < 10 -> Acc; +get_line_number_digits(Number, Acc) -> + get_line_number_digits(Number div 10, Acc + 1). + +n_spaces(N) -> lists:duplicate(N, " "). + +%% Compilation error/warn handling. + +%% Low-level warning, should be used only from Erlang passes. +-spec erl_warn(location() | none, unicode:chardata(), unicode:chardata()) -> ok. +erl_warn(none, File, Warning) -> + erl_warn(0, File, Warning); +erl_warn(Location, File, Warning) when is_binary(File) -> + emit_diagnostic(warning, Location, File, Warning, [], [{read_snippet, true}]). + +-spec file_warn(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> ok. +file_warn(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) -> + file_warn(Meta, #{file => File}, Module, Desc); +file_warn(Meta, E, Module, Desc) when is_list(Meta) -> + % Skip warnings during bootstrap, they will be reported during recompilation + case elixir_config:is_bootstrap() of + true -> ok; + false -> + {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, E), + Message = Module:format_error(Desc), + emit_diagnostic(warning, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]) + end. + +-spec file_error(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> no_return(). +file_error(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) -> + file_error(Meta, #{file => File}, Module, Desc); +file_error(Meta, Env, Module, Desc) when is_list(Meta) -> + print_error(Meta, Env, Module, Desc), + compile_error(Env). + +%% A module error is one where it can continue if there is a module +%% being compiled. If there is no module, it is a regular file_error. +-spec module_error(list(), #{file := binary(), module => module() | nil, _ => _}, module(), any()) -> ok. +module_error(Meta, #{module := EnvModule} = Env, Module, Desc) when EnvModule /= nil -> + print_error(Meta, Env, Module, Desc), + case elixir_module:taint(EnvModule) of + true -> ok; + false -> compile_error(Env) + end; +module_error(Meta, Env, Module, Desc) -> + file_error(Meta, Env, Module, Desc). + +%% A function error is one where it can continue if there is a function +%% being compiled. If there is no function, it is falls back to file_error. +-spec function_error(list(), #{file := binary(), function => {term(), term()} | nil, _ => _}, module(), any()) -> ok. +function_error(Meta, #{function := {_, _}} = Env, Module, Desc) -> + module_error(Meta, Env, Module, Desc); +function_error(Meta, Env, Module, Desc) -> + file_error(Meta, Env, Module, Desc). + +print_error(Meta, Env, Module, Desc) -> + {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, Env), + Message = Module:format_error(Desc), + emit_diagnostic(error, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]), + ok. + +%% Compilation error. + +-spec compile_error(#{file := binary(), _ => _}) -> no_return(). +%% We check for the lexical tracker because pry() inside a module +%% will have the environment but not a tracker. +compile_error(#{module := Module, file := File, lexical_tracker := LT}) when Module /= nil, LT /= nil -> + Inspected = elixir_aliases:inspect(Module), + Message = io_lib:format("cannot compile module ~ts (errors have been logged)", [Inspected]), + compile_error([], File, Message); +compile_error(#{file := File}) -> + compile_error([], File, "cannot compile file (errors have been logged)"). + +-spec compile_error(list(), binary(), binary() | unicode:charlist()) -> no_return(). +compile_error(Meta, File, Message) when is_binary(Message) -> + {File, Position} = meta_location(Meta, File), + raise('Elixir.CompileError', Message, [{file, File} | Position]); +compile_error(Meta, File, Message) when is_list(Message) -> + {File, Position} = meta_location(Meta, File), + raise('Elixir.CompileError', elixir_utils:characters_to_binary(Message), [{file, File} | Position]). + +%% Tokenization parsing/errors. + +-spec parse_error(elixir:keyword(), binary() | {binary(), binary()}, + binary(), binary(), {unicode:charlist(), integer(), integer()}) -> no_return(). +parse_error(Location, File, Error, <<>>, Input) -> + Message = case Error of + <<"syntax error before: ">> -> <<"syntax error: expression is incomplete">>; + _ -> <> + end, + + raise_snippet(Location, File, Input, 'Elixir.TokenMissingError', Message); + +%% Show a nicer message for end of line +parse_error(Location, File, <<"syntax error before: ">>, <<"eol">>, Input) -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', + <<"unexpectedly reached end of line. The current expression is invalid or incomplete">>); + +%% Show a nicer message for keywords pt1 (Erlang keywords show up wrapped in single quotes) +parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input) + when Keyword == <<"'not'">>; + Keyword == <<"'and'">>; + Keyword == <<"'or'">>; + Keyword == <<"'when'">>; + Keyword == <<"'after'">>; + Keyword == <<"'catch'">>; + Keyword == <<"'end'">> -> + raise_reserved(Location, File, Input, binary_part(Keyword, 1, byte_size(Keyword) - 2)); + +%% Show a nicer message for keywords pt2 (Elixir keywords show up as is) +parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input) + when Keyword == <<"fn">>; + Keyword == <<"else">>; + Keyword == <<"rescue">>; + Keyword == <<"true">>; + Keyword == <<"false">>; + Keyword == <<"nil">>; + Keyword == <<"in">> -> + raise_reserved(Location, File, Input, Keyword); + +%% Produce a human-readable message for errors before a sigil +parse_error(Location, File, <<"syntax error before: ">>, <<"{sigil,", _Rest/binary>> = Full, Input) -> + {ok, {sigil, _, Atom, [Content | _], _, _, _}} = parse_erl_term(Full), + Content2 = case is_binary(Content) of + true -> Content; + false -> <<>> + end, + + % :static_atoms_encoder might encode :sigil_ atoms as arbitrary terms + MaybeSigil = case is_atom(Atom) of + true -> case atom_to_binary(Atom) of + <<"sigil_", Chars/binary>> -> <<"\~", Chars/binary, " ">>; + _ -> <<>> + end; + false -> <<>> + end, + + Message = <<"syntax error before: sigil ", MaybeSigil/binary, "starting with content '", Content2/binary, "'">>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Binaries (and interpolation) are wrapped in [<<...>>] +parse_error(Location, File, Error, <<"[", _/binary>> = Full, Input) when is_binary(Error) -> + Term = case parse_erl_term(Full) of + {ok, [H | _]} when is_binary(H) -> <<$", H/binary, $">>; + _ -> <<$">> + end, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', <>); + +%% Given a string prefix and suffix to insert the token inside the error message rather than append it +parse_error(Location, File, {ErrorPrefix, ErrorSuffix}, Token, Input) when is_binary(ErrorPrefix), is_binary(ErrorSuffix), is_binary(Token) -> + Message = <>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Misplaced char tokens (for example, {char, _, 97}) are translated by Erlang into +%% the char literal (i.e., the token in the previous example becomes $a), +%% because {char, _, _} is a valid Erlang token for an Erlang char literal. We +%% want to represent that token as ?a in the error, according to the Elixir +%% syntax. +parse_error(Location, File, <<"syntax error before: ">>, <<$$, Char/binary>>, Input) -> + Message = <<"syntax error before: ?", Char/binary>>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Everything else is fine as is +parse_error(Location, File, Error, Token, Input) when is_binary(Error), is_binary(Token) -> + Message = <>, + case lists:keytake(error_type, 1, Location) of + {value, {error_type, mismatched_delimiter}, Loc} -> + raise_snippet(Loc, File, Input, 'Elixir.MismatchedDelimiterError', Message); + _ -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message) + end. + +parse_erl_term(Term) -> + case erl_scan:string(binary_to_list(Term)) of + {ok, Tokens, _} -> + case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of + {ok, Parsed} -> {ok, Parsed}; + _ -> error + end; + _ -> error + end. + +raise_reserved(Location, File, Input, Keyword) -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', + <<"syntax error before: ", Keyword/binary, ". \"", Keyword/binary, "\" is a " + "reserved word in Elixir and therefore its usage is limited. For instance, " + "it can't be used as a variable or be defined nor invoked as a regular function">>). + +raise_snippet(Location, File, Input, Kind, Message) when is_binary(File) -> + Snippet = cut_snippet(Location, Input), + raise(Kind, Message, [{file, File}, {snippet, Snippet} | Location]). + +cut_snippet(Location, Input) -> + case lists:keyfind(column, 1, Location) of + {column, _} -> + {line, Line} = lists:keyfind(line, 1, Location), + + case lists:keyfind(end_line, 1, Location) of + {end_line, EndLine} -> + cut_snippet(Input, Line, EndLine - Line + 1); + + false -> + Snippet = cut_snippet(Input, Line, 1), + case string:trim(Snippet, leading) of + <<>> -> nil; + _ -> Snippet + end + end; + + false -> + nil + end. + +cut_snippet({InputString, StartLine, StartColumn}, Line, Span) -> + %% In case the code is indented, we need to add the indentation back + %% for the snippets to match the reported columns. + Indent = binary:copy(<<" ">>, StartColumn - 1), + Lines = string:split(InputString, "\n", all), + [Head | Tail] = lists:nthtail(Line - StartLine, Lines), + IndentedTail = indent_n(Tail, Span - 1, <<"\n", Indent/binary>>), + elixir_utils:characters_to_binary([Indent, Head, IndentedTail]). + +indent_n([], _Count, _Indent) -> []; +indent_n(_Lines, 0, _Indent) -> []; +indent_n([H | T], Count, Indent) -> [Indent, H | indent_n(T, Count - 1, Indent)]. + +%% Helpers + +prefix(warning) -> highlight(<<"warning:">>, warning); +prefix(error) -> highlight(<<"error:">>, error); +prefix(hint) -> highlight(<<"hint:">>, hint). + +highlight(Message, Severity) -> + case {Severity, application:get_env(elixir, ansi_enabled, false)} of + {warning, true} -> yellow(Message); + {error, true} -> red(Message); + {hint, true} -> blue(Message); + _ -> Message + end. + +yellow(Msg) -> ["\e[33m", Msg, "\e[0m"]. +blue(Msg) -> ["\e[34m", Msg, "\e[0m"]. +red(Msg) -> ["\e[31m", Msg, "\e[0m"]. + +env_format(Meta, #{file := EnvFile} = E) -> + {File, Position} = meta_location(Meta, EnvFile), + Line = ?line(Position), + + Stacktrace = + case E of + #{function := {Name, Arity}, module := Module} -> + [{Module, Name, Arity, [{file, elixir_utils:relative_to_cwd(File)} | Position ]}]; + #{module := Module} when Module /= nil -> + [{Module, '__MODULE__', 0, [{file, elixir_utils:relative_to_cwd(File)} | Position]}]; + #{} -> + [] + end, + + case lists:keyfind(column, 1, Position) of + {column, Column} -> {{Line, Column}, File, Stacktrace}; + _ -> {Line, File, Stacktrace} + end. + +%% We prefer the stacktrace, if available, as it also contains module/function. +location_format(_Position, _File, [E | _]) -> + 'Elixir.Exception':format_stacktrace_entry(E); +location_format(Position, File, []) -> + file_format(Position, File). + +file_format({0, _Column}, File) -> + elixir_utils:relative_to_cwd(File); +file_format({Line, nil}, File) -> + file_format(Line, File); +file_format({Line, Column}, File) -> + io_lib:format("~ts:~w:~w", [elixir_utils:relative_to_cwd(File), Line, Column]); +file_format(0, File) -> + elixir_utils:relative_to_cwd(File); +file_format(Line, File) -> + io_lib:format("~ts:~w", [elixir_utils:relative_to_cwd(File), Line]). + +meta_location(Meta, File) -> + case elixir_utils:meta_keep(Meta) of + {F, L} -> {F, [{line, L}]}; + nil -> {File, maybe_add_col([{line, ?line(Meta)}], Meta)} + end. + +maybe_add_col(Position, Meta) -> + case lists:keyfind(column, 1, Meta) of + {column, Col} when is_integer(Col) -> [{column, Col} | Position]; + false -> Position + end. + +raise(Kind, Message, Opts) when is_binary(Message) -> + Stacktrace = try throw(ok) catch _:_:Stack -> Stack end, + Exception = Kind:exception([{description, Message} | Opts]), + erlang:raise(error, Exception, tl(Stacktrace)). + diff --git a/forge/src/future_elixir_interpolation.erl b/forge/src/future_elixir_interpolation.erl new file mode 100644 index 00000000..1f62eb6f --- /dev/null +++ b/forge/src/future_elixir_interpolation.erl @@ -0,0 +1,295 @@ +% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_interpolation.erl +% Handle string and string-like interpolations. +-module(future_elixir_interpolation). +-export([extract/6, unescape_string/1, unescape_string/2, +unescape_tokens/1, unescape_map/1]). +-include("future_elixir.hrl"). +-include("future_elixir_tokenizer.hrl"). + +%% Extract string interpolations + +extract(Line, Column, Scope, Interpol, String, Last) -> + extract(String, [], [], Line, Column, Scope, Interpol, Last). + +%% Terminators + +extract([], _Buffer, _Output, Line, Column, #elixir_tokenizer{cursor_completion=false}, _Interpol, Last) -> + {error, {string, Line, Column, io_lib:format("missing terminator: ~ts", [[Last]]), []}}; + +extract([], Buffer, Output, Line, Column, Scope, _Interpol, _Last) -> + finish_extraction([], Buffer, Output, Line, Column, Scope); + +extract([Last | Rest], Buffer, Output, Line, Column, Scope, _Interpol, Last) -> + finish_extraction(Rest, Buffer, Output, Line, Column + 1, Scope); + +%% Going through the string + +extract([$\\, $\r, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n, $\r, $\\ | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\\, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n, $\\ | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\\, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) -> + NewScope = + %% TODO: Remove this on Elixir v2.0 + case Interpol of + true -> + Scope; + false -> + Msg = "using \\~ts to escape the closing of an uppercase sigil is deprecated, please use another delimiter or a lowercase sigil instead", + prepend_warning(Line, Column, io_lib:format(Msg, [[Last]]), Scope) + end, + + extract(Rest, [Last | Buffer], Output, Line, Column+2, NewScope, Interpol, Last); + +extract([$\\, Last, Last, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, [Last, Last, Last] = All) -> + extract(Rest, [Last, Last, Last | Buffer], Output, Line, Column+4, Scope, Interpol, All); + +extract([$\\, $#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) -> + extract(Rest, [${, $#, $\\ | Buffer], Output, Line, Column+3, Scope, true, Last); + +extract([$#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) -> + Output1 = build_string(Buffer, Output), + case future_elixir_tokenizer:tokenize(Rest, Line, Column + 2, Scope#elixir_tokenizer{terminators=[]}) of + {error, {Location, _, "}"}, [$} | NewRest], Warnings, Tokens} -> + NewScope = Scope#elixir_tokenizer{warnings=Warnings}, + {line, EndLine} = lists:keyfind(line, 1, Location), + {column, EndColumn} = lists:keyfind(column, 1, Location), + Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens), Output1), + extract(NewRest, [], Output2, EndLine, EndColumn + 1, NewScope, true, Last); + {error, Reason, _, _, _} -> + {error, Reason}; + {ok, EndLine, EndColumn, Warnings, Tokens, Terminators} when Scope#elixir_tokenizer.cursor_completion /= false -> + NewScope = Scope#elixir_tokenizer{warnings=Warnings, cursor_completion=noprune}, + Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens, Terminators), Output1), + extract([], [], Output2, EndLine, EndColumn, NewScope, true, Last); + {ok, _, _, _, _, _} -> + {error, {string, Line, Column, "missing interpolation terminator: \"}\"", []}} + end; + +extract([$\\ | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) -> + extract_char(Rest, [$\\ | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + +%% Catch all clause + +extract([Char1, Char2 | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) + when Char1 =< 255, Char2 =< 255 -> + extract([Char2 | Rest], [Char1 | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + +extract(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) -> + extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last). + +extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) -> + case unicode_util:gc(Rest) of + [Char | _] when ?bidi(Char) -> + Token = io_lib:format("\\u~4.16.0B", [Char]), + Pre = "invalid bidirectional formatting character in string: ", + Pos = io_lib:format(". If you want to use such character, use it in its escaped ~ts form instead", [Token]), + {error, {?LOC(Line, Column), {Pre, Pos}, Token}}; + + [Char | NewRest] -> + extract(NewRest, [Char | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + + [] -> + extract([], Buffer, Output, Line, Column, Scope, Interpol, Last) + end. + +%% Handle newlines. Heredocs require special attention + +extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, [H,H,H] = Last) -> + case strip_horizontal_space(Rest, Buffer, 1) of + {[H,H,H|NewRest], _NewBuffer, Column} -> + finish_extraction(NewRest, Buffer, Output, Line + 1, Column + 3, Scope); + {NewRest, NewBuffer, Column} -> + extract(NewRest, NewBuffer, Output, Line + 1, Column, Scope, Interpol, Last) + end; +extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, Last) -> + extract(Rest, Buffer, Output, Line + 1, Scope#elixir_tokenizer.column, Scope, Interpol, Last). + +strip_horizontal_space([H | T], Buffer, Counter) when H =:= $\s; H =:= $\t -> + strip_horizontal_space(T, [H | Buffer], Counter + 1); +strip_horizontal_space(T, Buffer, Counter) -> + {T, Buffer, Counter}. + +%% Unescape a series of tokens as returned by extract. + +unescape_tokens(Tokens) -> + try [unescape_token(Token, fun unescape_map/1) || Token <- Tokens] of + Unescaped -> {ok, Unescaped} + catch + {error, _Reason, _Token} = Error -> Error + end. + +unescape_token(Token, Map) when is_list(Token) -> + unescape_chars(elixir_utils:characters_to_binary(Token), Map); +unescape_token(Token, Map) when is_binary(Token) -> + unescape_chars(Token, Map); +unescape_token(Other, _Map) -> + Other. + +% Unescape string. This is called by Elixir. Wrapped by convenience. + +unescape_string(String) -> + unescape_string(String, fun unescape_map/1). + +unescape_string(String, Map) -> + try + unescape_chars(String, Map) + catch + {error, Reason, _} -> + Message = elixir_utils:characters_to_binary(Reason), + error('Elixir.ArgumentError':exception([{message, Message}])) + end. + +% Unescape chars. For instance, "\" "n" (two chars) needs to be converted to "\n" (one char). + +unescape_chars(String, Map) -> + unescape_chars(String, Map, <<>>). + +unescape_chars(<<$\\, $x, Rest/binary>>, Map, Acc) -> + case Map(hex) of + true -> unescape_hex(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $u, Rest/binary>>, Map, Acc) -> + case Map(unicode) of + true -> unescape_unicode(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $\n, Rest/binary>>, Map, Acc) -> + case Map(newline) of + true -> unescape_chars(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $\r, $\n, Rest/binary>>, Map, Acc) -> + case Map(newline) of + true -> unescape_chars(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, Escaped, Rest/binary>>, Map, Acc) -> + case Map(Escaped) of + false -> unescape_chars(Rest, Map, <>); + Other -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<>, Map, Acc) -> + unescape_chars(Rest, Map, <>); + +unescape_chars(<<>>, _Map, Acc) -> Acc. + +% Unescape Helpers + +unescape_hex(<>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + Bytes = list_to_integer([A, B], 16), + unescape_chars(Rest, Map, <>); + +%% TODO: Remove deprecated sequences on v2.0 + +unescape_hex(<>, Map, Acc) when ?is_hex(A) -> + io:format(standard_error, "warning: \\xH inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_hex(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_hex(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B], Acc, 16); + +unescape_hex(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C], Acc, 16); + +unescape_hex(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_hex(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16); + +unescape_hex(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16); + +unescape_hex(<<_/binary>>, _Map, _Acc) -> + throw({error, "invalid hex escape character, expected \\xHH where H is a hexadecimal digit", "\\x"}). + +%% Finish deprecated sequences + +unescape_unicode(<>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_unicode(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) -> + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_unicode(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + append_codepoint(Rest, Map, [A, B], Acc, 16); + +unescape_unicode(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> + append_codepoint(Rest, Map, [A, B, C], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) -> + append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) -> + append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16); + +unescape_unicode(<<_/binary>>, _Map, _Acc) -> + throw({error, "invalid Unicode escape character, expected \\uHHHH or \\u{H*} where H is a hexadecimal digit", "\\u"}). + +append_codepoint(Rest, Map, List, Acc, Base) -> + Codepoint = list_to_integer(List, Base), + try <> of + Binary -> unescape_chars(Rest, Map, Binary) + catch + error:badarg -> + throw({error, "invalid or reserved Unicode code point \\u{" ++ List ++ "}", "\\u"}) + end. + +unescape_map(newline) -> true; +unescape_map(unicode) -> true; +unescape_map(hex) -> true; +unescape_map($0) -> 0; +unescape_map($a) -> 7; +unescape_map($b) -> $\b; +unescape_map($d) -> $\d; +unescape_map($e) -> $\e; +unescape_map($f) -> $\f; +unescape_map($n) -> $\n; +unescape_map($r) -> $\r; +unescape_map($s) -> $\s; +unescape_map($t) -> $\t; +unescape_map($v) -> $\v; +unescape_map(E) -> E. + +% Extract Helpers + +finish_extraction(Remaining, Buffer, Output, Line, Column, Scope) -> + Final = case build_string(Buffer, Output) of + [] -> [[]]; + F -> F + end, + + {Line, Column, lists:reverse(Final), Remaining, Scope}. + +build_string([], Output) -> Output; +build_string(Buffer, Output) -> [lists:reverse(Buffer) | Output]. + +build_interpol(Line, Column, EndLine, EndColumn, Buffer, Output) -> + [{{Line, Column, nil}, {EndLine, EndColumn, nil}, Buffer} | Output]. + +prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) -> + Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}. diff --git a/forge/src/future_elixir_parser.erl b/forge/src/future_elixir_parser.erl new file mode 100644 index 00000000..3a4e2c24 --- /dev/null +++ b/forge/src/future_elixir_parser.erl @@ -0,0 +1,33586 @@ +-file("src/future_elixir_parser.yrl", 0). +-module(future_elixir_parser). +-file("src/future_elixir_parser.erl", 3). +-export([parse/1, parse_and_scan/1, format_error/1]). +-file("src/future_elixir_parser.yrl", 650). + +-define(columns(), get(elixir_parser_columns)). +-define(token_metadata(), get(elixir_token_metadata)). + +-define(id(Token), element(1, Token)). +-define(location(Token), element(2, Token)). +-define(exprs(Token), element(3, Token)). +-define(meta(Node), element(2, Node)). +-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')). + +-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}). +-import(lists, [reverse/1, reverse/2]). + +meta_from_token(Token) -> + meta_from_location(?location(Token)). + +meta_from_location({Line, Column, _}) -> + case ?columns() of + true -> [{line, Line}, {column, Column}]; + false -> [{line, Line}] + end. + +do_end_meta(Do, End) -> + case ?token_metadata() of + true -> + [{do, meta_from_location(?location(Do))}, {'end', meta_from_location(?location(End))}]; + false -> + [] + end. + +meta_from_token_with_closing(Begin, End) -> + case ?token_metadata() of + true -> + [{closing, meta_from_location(?location(End))} | meta_from_token(Begin)]; + false -> + meta_from_token(Begin) + end. + +append_non_empty(Left, []) -> Left; +append_non_empty(Left, Right) -> Left ++ Right. + +%% Handle metadata in literals + +handle_literal(Literal, Token) -> + handle_literal(Literal, Token, []). + +handle_literal(Literal, Token, ExtraMeta) -> + case get(elixir_literal_encoder) of + false -> + Literal; + + Fun -> + Meta = ExtraMeta ++ meta_from_token(Token), + case Fun(Literal, Meta) of + {ok, EncodedLiteral} -> + EncodedLiteral; + {error, Reason} -> + return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [": "], "literal") + end + end. + +handle_number(Number, Token, Original) -> + case ?token_metadata() of + true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]); + false -> handle_literal(Number, Token, []) + end. + +number_value({_, {_, _, Value}, _}) -> + Value. + +%% Operators + +build_op(Left, {Op, Right}) -> + build_op(Left, Op, Right). + +build_op(AST, {_Kind, Location, '//'}, Right) -> + case AST of + {'..', Meta, [Left, Middle]} -> + {'..//', Meta, [Left, Middle, Right]}; + + _ -> + return_error(Location, "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: ", "'//'") + end; + +build_op({UOp, _, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) -> + %% TODO: Remove "not left in right" rearrangement on v2.0 + warn({Line, Column}, "\"not expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead"), + Meta = meta_from_location(Location), + {UOp, Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, 'not in'}, Right) -> + Meta = meta_from_location(Location), + {'not', Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, Op}, Right) -> + {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}. + +build_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) -> + {Outer, Inner} = + case ?columns() of + true -> {[{column, Column+1}], [{column, Column}]}; + false -> {[], []} + end, + {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]}; + +build_unary_op({_Kind, Location, Op}, Expr) -> + {Op, meta_from_location(Location), [Expr]}. + +build_nullary_op({_Kind, Location, Op}) -> + {Op, meta_from_location(Location), []}. + +build_list(Left, Args, Right) -> + {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}. + +build_tuple(Left, [Arg1, Arg2], Right) -> + handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right)); +build_tuple(Left, Args, Right) -> + {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_bit(Left, Args, Right) -> + {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map(Left, Args, Right) -> + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) -> + Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)), + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}. + +adjust_map_column(Map) -> + case ?columns() of + true -> + {'%{}', Meta, Pairs} = Map, + UpdatedMeta = [{Key, if Key =:= column -> Value - 1; true -> Value end} || + {Key, Value} <- Meta], + {'%{}', UpdatedMeta, Pairs}; + false -> + Map + end. + +%% Blocks + +build_block(Exprs) -> build_block(Exprs, []). + +build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) -> + {'__block__', Meta, Exprs}; +build_block([Expr], _Meta) -> + Expr; +build_block(Exprs, Meta) -> + {'__block__', Meta, Exprs}. + +%% Newlines + +newlines_pair(Left, Right) -> + case ?token_metadata() of + true -> + newlines(?location(Left), [{closing, meta_from_location(?location(Right))}]); + false -> + [] + end. + +newlines_op(Location) -> + case ?token_metadata() of + true -> newlines(Location, []); + false -> [] + end. + +next_is_eol(Token, {_, {_, _, Count}}) -> + {Line, Column, _} = ?location(Token), + setelement(2, Token, {Line, Column, Count}). + +newlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) -> + [{newlines, Count} | Meta]; +newlines(_, Meta) -> + Meta. + +annotate_eoe(Token, Stack) -> + case ?token_metadata() of + true -> + case {Token, Stack} of + {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) -> + [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest]; + + {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' -> + [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest]; + + _ -> + Stack + end; + false -> + Stack + end. + +end_of_expression({_, _, Count} = Location) when is_integer(Count) -> + [{newlines, Count} | meta_from_location(Location)]; +end_of_expression(Location) -> + meta_from_location(Location). + +%% Dots + +build_alias({'alias', Location, Alias}) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(Location)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Alias]}. + +build_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) -> + MetaWithExtra = + case ?token_metadata() of + true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)}); + false -> Meta + end, + {'__aliases__', MetaWithExtra, Left ++ [Right]}; +build_dot_alias(_Dot, Atom, Right) when is_atom(Atom) -> + error_bad_atom(Right); +build_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) -> + Meta = meta_from_token(Dot), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(SegmentLocation)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Expr, Right]}. + +build_dot_container(Dot, Left, Right, Extra) -> + Meta = meta_from_token(Dot), + {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}. + +build_dot(Dot, Left, {_, Location, _} = Right) -> + Meta = meta_from_token(Dot), + IdentifierLocation = meta_from_location(Location), + {'.', Meta, IdentifierLocation, [Left, extract_identifier(Right)]}. + +extract_identifier({Kind, _, Identifier}) when + Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier; + Kind == do_identifier; Kind == op_identifier -> + Identifier. + +%% Identifiers + +build_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) -> + Identifier = build_parens(Dot, Args1, {[], []}), + Meta = BlockMeta ++ Args2Meta ++ ?meta(Identifier), + {Identifier, Meta, append_non_empty(Args2, Block)}. + +build_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)), + {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens_do_block(Expr, Args, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block), + {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens(Expr, Args) -> + build_call(Expr, Args). + +build_identifier({'.', Meta, IdentifierLocation, DotArgs}) -> + {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierLocation], []}; + +build_identifier({'.', Meta, _} = Dot) -> + {Dot, [{no_parens, true} | Meta], []}; + +build_identifier({_, Location, Identifier}) -> + {Identifier, meta_from_location(Location), nil}. + +build_call({'.', Meta, IdentifierLocation, DotArgs}, Args) -> + {{'.', Meta, DotArgs}, IdentifierLocation, Args}; + +build_call({'.', Meta, _} = Dot, Args) -> + {Dot, Meta, Args}; + +build_call({op_identifier, Location, Identifier}, [Arg]) -> + {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]}; + +build_call({_, Location, Identifier}, Args) -> + {Identifier, meta_from_location(Location), Args}. + +%% Fn + +build_fn(Fn, Stab, End) -> + case check_stab(Stab, none) of + stab -> + Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End), + {fn, Meta, collect_stab(Stab, [], [])}; + block -> + return_error(?location(Fn), "expected anonymous functions to be defined with -> inside: ", "'fn'") + end. + +%% Access + +build_access_arg(Left, Args, Right) -> + {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}. + +build_access(Expr, {List, Meta}) -> + {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}. + +%% Interpolation aware + +build_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) -> + Meta = meta_from_location(Location), + MetaWithDelimiter = [{delimiter, Delimiter} | Meta], + MetaWithIndentation = meta_with_indentation(Meta, Indentation), + {Atom, + MetaWithDelimiter, + [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}. + +meta_with_indentation(Meta, nil) -> + Meta; +meta_with_indentation(Meta, Indentation) -> + [{indentation, Indentation} | Meta]. + +meta_with_from_brackets({List, Meta}) -> + {List, [{from_brackets, true} | Meta]}. + +build_bin_heredoc({bin_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$", $", $">>}, {indentation, Indentation}]; + false -> [] + end, + build_bin_string({bin_string, Location, Args}, ExtraMeta). + +build_list_heredoc({list_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}]; + false -> [] + end, + build_list_string({list_string, Location, Args}, ExtraMeta). + +build_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(H, Token, ExtraMeta); +build_bin_string({bin_string, Location, Args}, ExtraMeta) -> + Meta = + case ?token_metadata() of + true -> ExtraMeta ++ meta_from_location(Location); + false -> meta_from_location(Location) + end, + {'<<>>', Meta, string_parts(Args)}. + +build_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(elixir_utils:characters_to_list(H), Token, ExtraMeta); +build_list_string({list_string, Location, Args}, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}. + +build_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) -> + Op = binary_to_atom_op(Safe), + handle_literal(erlang:Op(H, utf8), Token, ExtraMeta); +build_quoted_atom({_, Location, Args}, Safe, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}. + +binary_to_atom_op(true) -> binary_to_existing_atom; +binary_to_atom_op(false) -> binary_to_atom. + +charlist_parts(Parts) -> + [charlist_part(Part) || Part <- Parts]. +charlist_part(Binary) when is_binary(Binary) -> + Binary; +charlist_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}. + +string_parts(Parts) -> + [string_part(Part) || Part <- Parts]. +string_part(Binary) when is_binary(Binary) -> + Binary; +string_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}. + +string_tokens_parse(Tokens) -> + case parse(Tokens) of + {ok, Forms} -> Forms; + {error, _} = Error -> throw(Error) + end. + +delimiter(Delimiter) -> + case ?token_metadata() of + true -> [{delimiter, Delimiter}]; + false -> [] + end. + +%% Keywords + +check_stab([{'->', _, [_, _]}], _) -> stab; +check_stab([], none) -> block; +check_stab([_], none) -> block; +check_stab([_], Meta) -> error_invalid_stab(Meta); +check_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta); +check_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta). + +build_stab(Stab) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab)); + stab -> collect_stab(Stab, [], []) + end. + +build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) -> + {'__block__', [], Exprs}; +build_paren_stab(Before, Stab, After) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After)); + stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After)) + end. + +collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) -> + Stab = {'->', Meta, [Left, build_block([Right | Exprs])]}, + collect_stab(T, [], [Stab | Stabs]); + +collect_stab([H | T], Exprs, Stabs) -> + collect_stab(T, [H | Exprs], Stabs); + +collect_stab([], [], Stabs) -> + Stabs. + +%% Every time the parser sees a (unquote_splicing()) +%% it assumes that a block is being spliced, wrapping +%% the splicing in a __block__. But in the stab clause, +%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such +%% case, we don't actually want the block, since it is +%% an arg style call. unwrap_splice unwraps the splice +%% from such blocks. +unwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) -> + Splice; +unwrap_splice(Other) -> + Other. + +unwrap_when(Args) -> + case elixir_utils:split_last(Args) of + {Start, {'when', Meta, [_, _] = End}} -> + [{'when', Meta, Start ++ End}]; + {_, _} -> + Args + end. + +%% Warnings and errors + +return_error({Line, Column, _}, ErrorMessage, ErrorToken) -> + return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]). + +%% We should prefer to use return_error as it includes +%% Line and Column but that's not always possible. +return_error_with_meta(Meta, ErrorMessage, ErrorToken) -> + return_error(Meta, [ErrorMessage, ErrorToken]). + +error_invalid_stab(MetaStab) -> + return_error_with_meta(MetaStab, + "unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. " + "Syntax error before: ", "'->'"). + +error_bad_atom(Token) -> + return_error(?location(Token), "atom cannot be followed by an alias. " + "If the '.' was meant to be part of the atom's name, " + "the atom name must be quoted. Syntax error before: ", "'.'"). + +bad_keyword(Token, Context) -> + return_error(?location(Token), + "unexpected keyword list inside " ++ atom_to_list(Context) ++ ". " + "Did you mean to write a map (using %{...}) or a list (using [...]) instead? " + "Syntax error after: ", "'{'"). + +maybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_call_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\n\n" + " function_call(1, some: :option, 2)\n\n" + "Instead, wrap the keyword in brackets:\n\n" + " function_call(1, [some: :option], 2)\n\n" + "Syntax error after: ", "','"). + +maybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_data_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\n\n" + " [some: :value, :another]\n" + " %{some: :value, another => value}\n\n" + "Instead, reorder it to be the last entry:\n\n" + " [:another, some: :value]\n" + " %{another => value, some: :value}\n\n" + "Syntax error after: ", "','"). + +error_no_parens_strict(Token) -> + return_error(?location(Token), "unexpected parentheses. If you are making a " + "function call, do not insert spaces between the function name and the " + "opening parentheses. Syntax error before: ", "'('"). + +error_no_parens_many_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n" + "This error happens when you have nested function calls without parentheses. " + "For example:\n\n" + " parent_call a, nested_call b, c, d\n\n" + "In the example above, we don't know if the parameters \"c\" and \"d\" apply " + "to the function \"parent_call\" or \"nested_call\". You can solve this by " + "explicitly adding parentheses:\n\n" + " parent_call a, nested_call(b, c, d)\n\n" + "Or by adding commas (in case a nested call is not intended):\n\n" + " parent_call a, nested_call, b, c, d\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_no_parens_container_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n" + "This error may happen when you forget a comma in a list or other container:\n\n" + " [a, b c, d]\n\n" + "Or when you have ambiguous calls:\n\n" + " [function a, b, c]\n\n" + "In the example above, we don't know if the values \"b\" and \"c\" " + "belongs to the list or the function \"function\". You can solve this by explicitly " + "adding parentheses:\n\n" + " [one, function(a, b, c)]\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_too_many_access_syntax(Comma) -> + return_error(?location(Comma), "too many arguments when accessing a value. " + "The value[key] notation in Elixir expects either a single argument or a keyword list. " + "The following examples are allowed:\n\n" + " value[one]\n" + " value[one: 1, two: 2]\n" + " value[[one, two, three]]\n\n" + "These are invalid:\n\n" + " value[1, 2, 3]\n" + " value[one, two, three]\n\n" + "Syntax error after: ", "','"). + +error_invalid_kw_identifier({_, Location, do}) -> + return_error(Location, elixir_tokenizer:invalid_do_error("unexpected keyword: "), "do:"); +error_invalid_kw_identifier({_, Location, KW}) -> + return_error(Location, "syntax error before: ", "'" ++ atom_to_list(KW) ++ ":'"). + +%% TODO: Make this an error on v2.0 +warn_trailing_comma({',', {Line, Column, _}}) -> + warn({Line, Column}, "trailing commas are not allowed inside function/macro call arguments"). + +%% TODO: Make this an error on v2.0 +warn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) -> + warn( + {Line, Column}, + io_lib:format( + "parentheses are required when piping into a function call. For example:\n\n" + " foo 1 ~ts bar 2 ~ts baz 3\n\n" + "is ambiguous and should be written as\n\n" + " foo(1) ~ts bar(2) ~ts baz(3)\n\n" + "Ambiguous pipe found at:", + [Op, Op, Op, Op] + ) + ); +warn_pipe(_Token, _) -> + ok. + +%% TODO: Make this an error on v2.0 +warn_no_parens_after_do_op({{_Type, Location, Op}, _}) -> + {Line, _, _} = Location, + + warn( + Line, + "missing parentheses on expression following operator \"" ++ atom_to_list(Op) ++ "\", " + "you must add parentheses to avoid ambiguities" + ). + +%% TODO: Make this an error on v2.0 +warn_nested_no_parens_keyword(Key, Value) when is_atom(Key) -> + {line, Line} = lists:keyfind(line, 1, ?meta(Value)), + warn( + Line, + "missing parentheses for expression following \"" ++ atom_to_list(Key) ++ ":\" keyword. " + "Parentheses are required to solve ambiguity inside keywords.\n\n" + "This error happens when you have function calls without parentheses inside keywords. " + "For example:\n\n" + " function(arg, one: nested_call a, b, c)\n" + " function(arg, one: if expr, do: :this, else: :that)\n\n" + "In the examples above, we don't know if the arguments \"b\" and \"c\" apply " + "to the function \"function\" or \"nested_call\". Or if the keywords \"do\" and " + "\"else\" apply to the function \"function\" or \"if\". You can solve this by " + "explicitly adding parentheses:\n\n" + " function(arg, one: if(expr, do: :this, else: :that))\n" + " function(arg, one: nested_call(a, b, c))\n\n" + "Ambiguity found at:" + ); + +% Key might not be an atom when using literal_encoder, we just skip the warning +warn_nested_no_parens_keyword(_Key, _Value) -> + ok. + +warn_empty_paren({_, {Line, Column, _}}) -> + warn( + {Line, Column}, + "invalid expression (). " + "If you want to invoke or define a function, make sure there are " + "no spaces between the function name and its arguments. If you wanted " + "to pass an empty block or code, pass a value instead, such as a nil or an atom" + ). + +warn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) -> + warn( + {Line, Column}, + "an expression is always required on the right side of ->. " + "Please provide a value after ->" + ). + +warn(LineColumn, Message) -> + case get(elixir_parser_warning_file) of + nil -> ok; + File -> future_elixir_errors:erl_warn(LineColumn, File, Message) + end. + +-file("/nix/store/xlav8m7x7v9wqhdqmzf4cnw3px12gsag-erlang-27.0/lib/erlang/lib/parsetools-2.6/include/yeccpre.hrl", 0). +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-2024. All Rights Reserved. +%% +%% Licensed under the Apache License, Version 2.0 (the "License"); +%% you may not use this file except in compliance with the License. +%% You may obtain a copy of the License at +%% +%% http://www.apache.org/licenses/LICENSE-2.0 +%% +%% Unless required by applicable law or agreed to in writing, software +%% distributed under the License is distributed on an "AS IS" BASIS, +%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +%% See the License for the specific language governing permissions and +%% limitations under the License. +%% +%% %CopyrightEnd% +%% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% The parser generator will insert appropriate declarations before this line.% + +-type yecc_ret() :: {'error', _} | {'ok', _}. + +-ifdef (YECC_PARSE_DOC). +-doc ?YECC_PARSE_DOC. +-endif. +-spec parse(Tokens :: list()) -> yecc_ret(). +parse(Tokens) -> + yeccpars0(Tokens, {no_func, no_location}, 0, [], []). + +-ifdef (YECC_PARSE_AND_SCAN_DOC). +-doc ?YECC_PARSE_AND_SCAN_DOC. +-endif. +-spec parse_and_scan({function() | {atom(), atom()}, [_]} + | {atom(), atom(), [_]}) -> yecc_ret(). +parse_and_scan({F, A}) -> + yeccpars0([], {{F, A}, no_location}, 0, [], []); +parse_and_scan({M, F, A}) -> + Arity = length(A), + yeccpars0([], {{fun M:F/Arity, A}, no_location}, 0, [], []). + +-ifdef (YECC_FORMAT_ERROR_DOC). +-doc ?YECC_FORMAT_ERROR_DOC. +-endif. +-spec format_error(any()) -> [char() | list()]. +format_error(Message) -> + case io_lib:deep_char_list(Message) of + true -> + Message; + _ -> + io_lib:write(Message) + end. + +%% To be used in grammar files to throw an error message to the parser +%% toplevel. Doesn't have to be exported! +-compile({nowarn_unused_function, return_error/2}). +-spec return_error(erl_anno:location(), any()) -> no_return(). +return_error(Location, Message) -> + throw({error, {Location, ?MODULE, Message}}). + +-define(CODE_VERSION, "1.4"). + +yeccpars0(Tokens, Tzr, State, States, Vstack) -> + try yeccpars1(Tokens, Tzr, State, States, Vstack) + catch + error: Error: Stacktrace -> + try yecc_error_type(Error, Stacktrace) of + Desc -> + erlang:raise(error, {yecc_bug, ?CODE_VERSION, Desc}, + Stacktrace) + catch _:_ -> erlang:raise(error, Error, Stacktrace) + end; + %% Probably thrown from return_error/2: + throw: {error, {_Location, ?MODULE, _M}} = Error -> + Error + end. + +yecc_error_type(function_clause, [{?MODULE,F,ArityOrArgs,_} | _]) -> + case atom_to_list(F) of + "yeccgoto_" ++ SymbolL -> + {ok,[{atom,_,Symbol}],_} = erl_scan:string(SymbolL), + State = case ArityOrArgs of + [S,_,_,_,_,_,_] -> S; + _ -> state_is_unknown + end, + {Symbol, State, missing_in_goto_table} + end. + +yeccpars1([Token | Tokens], Tzr, State, States, Vstack) -> + yeccpars2(State, element(1, Token), States, Vstack, Token, Tokens, Tzr); +yeccpars1([], {{F, A},_Location}, State, States, Vstack) -> + case apply(F, A) of + {ok, Tokens, EndLocation} -> + yeccpars1(Tokens, {{F, A}, EndLocation}, State, States, Vstack); + {eof, EndLocation} -> + yeccpars1([], {no_func, EndLocation}, State, States, Vstack); + {error, Descriptor, _EndLocation} -> + {error, Descriptor} + end; +yeccpars1([], {no_func, no_location}, State, States, Vstack) -> + Line = 999999, + yeccpars2(State, '$end', States, Vstack, yecc_end(Line), [], + {no_func, Line}); +yeccpars1([], {no_func, EndLocation}, State, States, Vstack) -> + yeccpars2(State, '$end', States, Vstack, yecc_end(EndLocation), [], + {no_func, EndLocation}). + +%% yeccpars1/7 is called from generated code. +%% +%% When using the {includefile, Includefile} option, make sure that +%% yeccpars1/7 can be found by parsing the file without following +%% include directives. yecc will otherwise assume that an old +%% yeccpre.hrl is included (one which defines yeccpars1/5). +yeccpars1(State1, State, States, Vstack, Token0, [Token | Tokens], Tzr) -> + yeccpars2(State, element(1, Token), [State1 | States], + [Token0 | Vstack], Token, Tokens, Tzr); +yeccpars1(State1, State, States, Vstack, Token0, [], {{_F,_A}, _Location}=Tzr) -> + yeccpars1([], Tzr, State, [State1 | States], [Token0 | Vstack]); +yeccpars1(State1, State, States, Vstack, Token0, [], {no_func, no_location}) -> + Location = yecctoken_end_location(Token0), + yeccpars2(State, '$end', [State1 | States], [Token0 | Vstack], + yecc_end(Location), [], {no_func, Location}); +yeccpars1(State1, State, States, Vstack, Token0, [], {no_func, Location}) -> + yeccpars2(State, '$end', [State1 | States], [Token0 | Vstack], + yecc_end(Location), [], {no_func, Location}). + +%% For internal use only. +yecc_end(Location) -> + {'$end', Location}. + +yecctoken_end_location(Token) -> + try erl_anno:end_location(element(2, Token)) of + undefined -> yecctoken_location(Token); + Loc -> Loc + catch _:_ -> yecctoken_location(Token) + end. + +-compile({nowarn_unused_function, yeccerror/1}). +yeccerror(Token) -> + Text = yecctoken_to_string(Token), + Location = yecctoken_location(Token), + {error, {Location, ?MODULE, ["syntax error before: ", Text]}}. + +-compile({nowarn_unused_function, yecctoken_to_string/1}). +yecctoken_to_string(Token) -> + try erl_scan:text(Token) of + undefined -> yecctoken2string(Token); + Txt -> Txt + catch _:_ -> yecctoken2string(Token) + end. + +yecctoken_location(Token) -> + try erl_scan:location(Token) + catch _:_ -> element(2, Token) + end. + +-compile({nowarn_unused_function, yecctoken2string/1}). +yecctoken2string(Token) -> + try + yecctoken2string1(Token) + catch + _:_ -> + io_lib:format("~tp", [Token]) + end. + +-compile({nowarn_unused_function, yecctoken2string1/1}). +yecctoken2string1({atom, _, A}) -> io_lib:write_atom(A); +yecctoken2string1({integer,_,N}) -> io_lib:write(N); +yecctoken2string1({float,_,F}) -> io_lib:write(F); +yecctoken2string1({char,_,C}) -> io_lib:write_char(C); +yecctoken2string1({var,_,V}) -> io_lib:format("~s", [V]); +yecctoken2string1({string,_,S}) -> io_lib:write_string(S); +yecctoken2string1({reserved_symbol, _, A}) -> io_lib:write(A); +yecctoken2string1({_Cat, _, Val}) -> io_lib:format("~tp", [Val]); +yecctoken2string1({dot, _}) -> "'.'"; +yecctoken2string1({'$end', _}) -> []; +yecctoken2string1({Other, _}) when is_atom(Other) -> + io_lib:write_atom(Other); +yecctoken2string1(Other) -> + io_lib:format("~tp", [Other]). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + +-file("src/future_elixir_parser.erl", 829). + +-dialyzer({nowarn_function, yeccpars2/7}). +-compile({nowarn_unused_function, yeccpars2/7}). +yeccpars2(0=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_0(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(1=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_1(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(2=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(3=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_3(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(4=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_4(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(5=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_5(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(6=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(7=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_7(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(8=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_8(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(9=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(10=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_10(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(11=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_11(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(12=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_12(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(13=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_13(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(14=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_14(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(15=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_15(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(16=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_16(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(17=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_17(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(18=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(19=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_19(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(20=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_20(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(21=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_21(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(22=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_22(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(23=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_23(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(24=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_24(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(25=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_25(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(26=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(27=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_27(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(28=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_28(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(29=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_29(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(30=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_30(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(31=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_31(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(32=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(33=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_33(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(34=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_34(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(35=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_35(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(36=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_36(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(37=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(38=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_38(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(39=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(40=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_40(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(41=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_41(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(42=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_42(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(43=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_43(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(44=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_44(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(45=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_45(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(46=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_46(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(47=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_47(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(48=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_48(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(49=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_49(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(50=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_50(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(51=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_51(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(52=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_52(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(53=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_53(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(54=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_54(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(55=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_55(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(56=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_56(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(57=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_57(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(58=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_58(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(59=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_59(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(60=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_60(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(61=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_61(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(62=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_62(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(63=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(64=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_64(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(65=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_65(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(66=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_66(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(67=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_67(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(68=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_68(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(69=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_69(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(70=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_70(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(71=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_71(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(72=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_72(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(73=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_73(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(74=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_74(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(75=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_75(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(76=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_76(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(77=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_77(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(78=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_78(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(79=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_79(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(80=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_80(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(81=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_81(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(82=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_82(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(83=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_83(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(84=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_84(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(85=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(86=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(87=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_87(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(88=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(89=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(90=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(91=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(92=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(93=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(94=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(95=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_95(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(96=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(97=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_97(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(98=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(99=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(100=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(101=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(102=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_102(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(103=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(104=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(105=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(106=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(107=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_107(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(108=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(109=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_109(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(110=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_110(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(111=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_111(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(112=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_112(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(113=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_113(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(114=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_114(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(115=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_115(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(116=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_116(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(117=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_117(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(118=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_118(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(119=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_119(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(120=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_120(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(121=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_121(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(122=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_122(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(123=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_123(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(124=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_124(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(125=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_125(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(126=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_126(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(127=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_127(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(128=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_128(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(129=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_129(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(130=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_130(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(131=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_131(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(132=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_132(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(133=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_133(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(134=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_134(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(135=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_135(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(136=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_136(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(137=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_137(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(138=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_138(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(139=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_139(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(140=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_140(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(141=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_141(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(142=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_142(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(143=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_143(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(144=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_144(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(145=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_145(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(146=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_146(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(147=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_147(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(148=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_148(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(149=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_149(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(150=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_150(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(151=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_151(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(152=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_152(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(153=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_153(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(154=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_154(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(155=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_155(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(156=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_156(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(157=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_157(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(158=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_158(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(159=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_159(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(160=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_160(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(161=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_161(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(162=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_162(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(163=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_163(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(164=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_164(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(165=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_165(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(166=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_166(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(167=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_167(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(168=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_168(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(169=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_169(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(170=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_170(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(171=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_171(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(172=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_172(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(173=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(174=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(175=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_175(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(176=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_176(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(177=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_177(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(178=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(179=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(180=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_180(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(181=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(182=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_182(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(183=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_183(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(184=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_184(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(185=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(186=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(187=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_187(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(188=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(189=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_189(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(190=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_190(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(191=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(192=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(193=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(194=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(195=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_197(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(198=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_29(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(200=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(201=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_201(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(202=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_202(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(203=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(204=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(206=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(208=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(209=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(211=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(212=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(213=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(214=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(215=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(217=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(220=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(221=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_221(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_222(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(223=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_223(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_224(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(225=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_225(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(226=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_226(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(227=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_227(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(228=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_228(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_229(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(230=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_230(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_231(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(232=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_232(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(233=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_233(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(234=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_234(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_235(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(236=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_236(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(237=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_237(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(238=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_238(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_239(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(240=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_30(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(241=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_241(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(242=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(243=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_243(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(244=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(245=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(246=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(247=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_247(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(250=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_250(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(251=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_251(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(252=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_253(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(254=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_254(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(255=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_255(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(256=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_256(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(257=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_257(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(258=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(259=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_259(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(260=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_260(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(261=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_261(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(262=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(263=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_263(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(265=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_265(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(266=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_266(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(267=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(268=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_268(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_269(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(270=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_270(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_272(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(273=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_273(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(274=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_274(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(275=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(276=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_276(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(277=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_277(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(278=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_278(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(279=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_279(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(280=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_280(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(281=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_281(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(282=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_282(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(283=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_284(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(285=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_285(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(286=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_286(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(287=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(288=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_288(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(289=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_289(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(291=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_291(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(292=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_292(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(293=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(294=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_294(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(295=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(296=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(297=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(298=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_298(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(299=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_299(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(301=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(304=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(305=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(306=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(307=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(308=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(311=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(312=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(313=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(314=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(315=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(317=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(318=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_318(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(319=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(320=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_320(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(321=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_321(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(322=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_322(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(323=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_323(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(324=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_324(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(325=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_325(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(326=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_326(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(327=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_327(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(328=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_328(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(329=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(330=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_330(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(331=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_331(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(332=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_332(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(333=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_333(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(334=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_334(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(335=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_335(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(336=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_336(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(337=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_337(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(338=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_338(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(339=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_339(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(340=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_340(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(341=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_341(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(342=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_342(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(343=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_343(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(344=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_344(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(345=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_345(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(346=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_346(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(347=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_347(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(348=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_348(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(349=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_349(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(350=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_350(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(351=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_351(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(352=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_352(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(353=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_353(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(354=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_354(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(355=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(356=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_356(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(357=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_357(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(358=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_358(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(359=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(360=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_360(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(361=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_361(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(362=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(363=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_363(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(364=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_364(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(365=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_365(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(366=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_366(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(367=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(368=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_368(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(369=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_369(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(370=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_370(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(371=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_371(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(372=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_372(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(373=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_373(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(374=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_374(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(375=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_375(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(376=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(377=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_377(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(378=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_378(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(379=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_379(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(380=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_380(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(381=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_381(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(382=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_382(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(383=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_383(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(384=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_384(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(385=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(386=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_386(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(387=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_387(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(388=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_388(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(389=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_389(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(390=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_390(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(391=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_391(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(392=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_392(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(393=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_393(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(394=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_394(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(395=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_395(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(396=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_396(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(397=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(398=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(399=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(400=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_400(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(401=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_401(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(402=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_402(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(403=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_403(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(404=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_404(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(405=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_405(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(406=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_406(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(407=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_407(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(408=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_408(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(409=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_409(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(410=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(411=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(412=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_412(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(413=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_413(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(414=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_414(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(415=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_415(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(416=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_416(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(417=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_417(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(418=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_418(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(419=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_419(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(420=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_420(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(421=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_421(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(422=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_422(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(423=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_423(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(424=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_424(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(425=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_425(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(426=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_426(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(427=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_427(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(428=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_428(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(429=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_429(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(430=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_430(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(431=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_431(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(432=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_432(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(433=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_433(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(434=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_434(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(435=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_435(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(436=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_436(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(437=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_437(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(438=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_438(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(439=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_439(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(440=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_440(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(441=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_441(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(442=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_442(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(443=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_443(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(444=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_444(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(445=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_445(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(446=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_446(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(447=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_447(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(448=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_448(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(449=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_449(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(450=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_450(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(451=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_451(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(452=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_452(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(453=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_453(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(454=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_454(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(455=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_455(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(456=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_456(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(457=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(458=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_458(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(459=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_459(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(460=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_460(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(461=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(462=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_462(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(463=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_463(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(464=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_464(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(465=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_465(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(466=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_466(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(467=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(468=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_468(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(469=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(470=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(471=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(472=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_472(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(473=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_473(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(474=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(475=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(476=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_476(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(477=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(478=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(479=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(480=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_480(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(481=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_481(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(482=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_482(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(483=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(484=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_484(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(485=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_485(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(486=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(487=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(488=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_488(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(489=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_489(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(490=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_490(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(491=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_491(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(492=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_492(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(493=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_493(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(494=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_494(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(495=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_495(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(496=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_496(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(497=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_497(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(498=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(499=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(500=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(501=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_501(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(502=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_502(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(503=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(504=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(505=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(506=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(507=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(508=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(509=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(510=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(511=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(512=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(513=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(514=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(515=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(516=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(517=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(518=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(519=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(520=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(521=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(522=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_522(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(523=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_523(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(524=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(525=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_525(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(526=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(527=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_527(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(528=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_528(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(529=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_529(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(530=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_530(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(531=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_531(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(532=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_532(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(533=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_533(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(534=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_534(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(535=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_535(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(536=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_536(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(537=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_537(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(538=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_538(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(539=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_539(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(540=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_540(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(541=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_541(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(542=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_542(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(543=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_543(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(544=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_544(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(545=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_545(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(546=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_546(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(547=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(548=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_548(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(549=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_549(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(550=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_550(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(551=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_551(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(552=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_552(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(553=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_553(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(554=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_554(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(555=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_555(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(556=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_556(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(557=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_557(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(558=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_558(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(559=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_559(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(560=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_560(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(561=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_561(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(562=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_562(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(563=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_563(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(564=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_564(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(565=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_565(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(566=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_566(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(567=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_567(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(568=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_568(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(569=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_569(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(570=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_570(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(571=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_571(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(572=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_572(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(573=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_573(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(574=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_574(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(575=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_575(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(576=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_576(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(577=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_558(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(578=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_578(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(579=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_579(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(580=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_580(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(581=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_581(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(582=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_582(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(583=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_583(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(584=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_584(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(585=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_585(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(586=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_586(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(587=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_587(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(588=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_588(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(589=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_589(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(590=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_590(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(591=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_591(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(592=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_592(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(593=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_593(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(594=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_594(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(595=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_595(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(596=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_596(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(597=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_597(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(598=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_598(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(599=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_599(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(600=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_600(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(601=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_601(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(602=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_602(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(603=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_603(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(604=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_604(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(605=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_605(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(606=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_606(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(607=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_607(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(608=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_608(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(609=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_609(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(610=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_610(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(611=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_611(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(612=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_612(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(613=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_613(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(614=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_614(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(615=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(616=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_616(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(617=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_617(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(618=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_618(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(619=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_619(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(620=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_620(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(621=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_621(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(622=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_622(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(623=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(624=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_624(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(625=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_625(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(626=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_626(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(Other, _, _, _, _, _, _) -> + erlang:error({yecc_bug,"1.4",{missing_state_in_action_table, Other}}). + +-dialyzer({nowarn_function, yeccpars2_0/7}). +-compile({nowarn_unused_function, yeccpars2_0/7}). +yeccpars2_0(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_0_(Stack), + yeccpars2_19(19, Cat, [0 | Ss], NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_1/7}). +-compile({nowarn_unused_function, yeccpars2_1/7}). +yeccpars2_1(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_1_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_2(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_2/7}). +-compile({nowarn_unused_function, yeccpars2_2/7}). +yeccpars2_cont_2(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_3/7}). +-compile({nowarn_unused_function, yeccpars2_3/7}). +yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_3_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_4/7}). +-compile({nowarn_unused_function, yeccpars2_4/7}). +yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_4_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_5/7}). +-compile({nowarn_unused_function, yeccpars2_5/7}). +yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_5_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_6(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 386, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 387, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_7(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 624, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_8(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 618, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_9(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 609, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_10/7}). +-compile({nowarn_unused_function, yeccpars2_10/7}). +yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_10_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_11/7}). +-compile({nowarn_unused_function, yeccpars2_11/7}). +yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_11_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_12/7}). +-compile({nowarn_unused_function, yeccpars2_12/7}). +yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_12_(Stack), + yeccgoto_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_13/7}). +-compile({nowarn_unused_function, yeccpars2_13/7}). +yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_13_(Stack), + yeccgoto_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_14/7}). +-compile({nowarn_unused_function, yeccpars2_14/7}). +yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_14_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_15/7}). +-compile({nowarn_unused_function, yeccpars2_15/7}). +yeccpars2_15(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_15_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_16/7}). +-compile({nowarn_unused_function, yeccpars2_16/7}). +yeccpars2_16(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_16(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_17/7}). +-compile({nowarn_unused_function, yeccpars2_17/7}). +yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_17_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_18/7}). +-compile({nowarn_unused_function, yeccpars2_18/7}). +yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_18_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_19/7}). +-compile({nowarn_unused_function, yeccpars2_19/7}). +yeccpars2_19(_S, '$end', _Ss, Stack, _T, _Ts, _Tzr) -> + {ok, hd(Stack)}; +yeccpars2_19(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_20(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_21/7}). +-compile({nowarn_unused_function, yeccpars2_21/7}). +yeccpars2_21(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_21(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_21(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_21_(Stack), + yeccgoto_grammar(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_22/7}). +-compile({nowarn_unused_function, yeccpars2_22/7}). +yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_22_(Stack), + yeccgoto_expr_list(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_23/7}). +-compile({nowarn_unused_function, yeccpars2_23/7}). +yeccpars2_23(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_23_(Stack), + yeccgoto_grammar(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_24/7}). +-compile({nowarn_unused_function, yeccpars2_24/7}). +yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_24_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_25/7}). +-compile({nowarn_unused_function, yeccpars2_25/7}). +yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_25_(Stack), + yeccgoto_dot_call_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_26(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_27/7}). +-compile({nowarn_unused_function, yeccpars2_27/7}). +yeccpars2_27(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_27_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_28/7}). +-compile({nowarn_unused_function, yeccpars2_28/7}). +yeccpars2_28(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_28(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_28_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_29/7}). +-compile({nowarn_unused_function, yeccpars2_29/7}). +yeccpars2_29(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_29(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_30/7}). +-compile({nowarn_unused_function, yeccpars2_30/7}). +yeccpars2_30(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_30(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_31/7}). +-compile({nowarn_unused_function, yeccpars2_31/7}). +yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_31_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_32: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_33/7}). +-compile({nowarn_unused_function, yeccpars2_33/7}). +yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_33_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_34/7}). +-compile({nowarn_unused_function, yeccpars2_34/7}). +yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_34_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_35/7}). +-compile({nowarn_unused_function, yeccpars2_35/7}). +yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_35_(Stack), + yeccgoto_unmatched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_36/7}). +-compile({nowarn_unused_function, yeccpars2_36/7}). +yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_36_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_37: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_38/7}). +-compile({nowarn_unused_function, yeccpars2_38/7}). +yeccpars2_38(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_38(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr); +yeccpars2_38(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_38_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_39(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 462, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_40/7}). +-compile({nowarn_unused_function, yeccpars2_40/7}). +yeccpars2_40(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 456, Ss, Stack, T, Ts, Tzr); +yeccpars2_40(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_40_(Stack), + yeccgoto_map_op(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_41/7}). +-compile({nowarn_unused_function, yeccpars2_41/7}). +yeccpars2_41(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 455, Ss, Stack, T, Ts, Tzr); +yeccpars2_41(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_41_(Stack), + yeccgoto_open_paren(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_42/7}). +-compile({nowarn_unused_function, yeccpars2_42/7}). +yeccpars2_42(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_42_(Stack), + yeccgoto_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_43/7}). +-compile({nowarn_unused_function, yeccpars2_43/7}). +yeccpars2_43(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 454, Ss, Stack, T, Ts, Tzr); +yeccpars2_43(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_43_(Stack), + yeccgoto_open_bit(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_44/7}). +-compile({nowarn_unused_function, yeccpars2_44/7}). +yeccpars2_44(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 453, Ss, Stack, T, Ts, Tzr); +yeccpars2_44(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_44_(Stack), + yeccgoto_open_bracket(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_45/7}). +-compile({nowarn_unused_function, yeccpars2_45/7}). +yeccpars2_45(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_45_(Stack), + yeccgoto_dot_alias(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_46/7}). +-compile({nowarn_unused_function, yeccpars2_46/7}). +yeccpars2_46(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 452, Ss, Stack, T, Ts, Tzr); +yeccpars2_46(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_46_(Stack), + yeccgoto_at_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_47/7}). +-compile({nowarn_unused_function, yeccpars2_47/7}). +yeccpars2_47(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_47_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_48/7}). +-compile({nowarn_unused_function, yeccpars2_48/7}). +yeccpars2_48(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_48_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_49/7}). +-compile({nowarn_unused_function, yeccpars2_49/7}). +yeccpars2_49(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_49_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_50/7}). +-compile({nowarn_unused_function, yeccpars2_50/7}). +yeccpars2_50(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_50_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_51/7}). +-compile({nowarn_unused_function, yeccpars2_51/7}). +yeccpars2_51(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_51_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_52/7}). +-compile({nowarn_unused_function, yeccpars2_52/7}). +yeccpars2_52(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_52_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_53/7}). +-compile({nowarn_unused_function, yeccpars2_53/7}). +yeccpars2_53(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_53_(Stack), + yeccgoto_dot_bracket_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_54/7}). +-compile({nowarn_unused_function, yeccpars2_54/7}). +yeccpars2_54(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 451, Ss, Stack, T, Ts, Tzr); +yeccpars2_54(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_55/7}). +-compile({nowarn_unused_function, yeccpars2_55/7}). +yeccpars2_55(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 450, Ss, Stack, T, Ts, Tzr); +yeccpars2_55(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_55_(Stack), + yeccgoto_capture_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_56/7}). +-compile({nowarn_unused_function, yeccpars2_56/7}). +yeccpars2_56(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_56_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_57/7}). +-compile({nowarn_unused_function, yeccpars2_57/7}). +yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_57_(Stack), + yeccgoto_dot_do_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_58/7}). +-compile({nowarn_unused_function, yeccpars2_58/7}). +yeccpars2_58(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 449, Ss, Stack, T, Ts, Tzr); +yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_58_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_59/7}). +-compile({nowarn_unused_function, yeccpars2_59/7}). +yeccpars2_59(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_59_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_60/7}). +-compile({nowarn_unused_function, yeccpars2_60/7}). +yeccpars2_60(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 81, Ss, Stack, T, Ts, Tzr); +yeccpars2_60(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_60_(Stack), + yeccgoto_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_61/7}). +-compile({nowarn_unused_function, yeccpars2_61/7}). +yeccpars2_61(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_61_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_62/7}). +-compile({nowarn_unused_function, yeccpars2_62/7}). +yeccpars2_62(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_62_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_63/7}). +-compile({nowarn_unused_function, yeccpars2_63/7}). +yeccpars2_63(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_63(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_63(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_63_(Stack), + yeccgoto_fn_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_64/7}). +-compile({nowarn_unused_function, yeccpars2_64/7}). +yeccpars2_64(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_64_(Stack), + yeccgoto_dot_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_65/7}). +-compile({nowarn_unused_function, yeccpars2_65/7}). +yeccpars2_65(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_65_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_66/7}). +-compile({nowarn_unused_function, yeccpars2_66/7}). +yeccpars2_66(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_66_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_67/7}). +-compile({nowarn_unused_function, yeccpars2_67/7}). +yeccpars2_67(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_67_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_68/7}). +-compile({nowarn_unused_function, yeccpars2_68/7}). +yeccpars2_68(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_68_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_69/7}). +-compile({nowarn_unused_function, yeccpars2_69/7}). +yeccpars2_69(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_69_(Stack), + yeccgoto_dot_op_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_70/7}). +-compile({nowarn_unused_function, yeccpars2_70/7}). +yeccpars2_70(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_70_(Stack), + yeccgoto_dot_paren_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_71/7}). +-compile({nowarn_unused_function, yeccpars2_71/7}). +yeccpars2_71(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_71_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_72/7}). +-compile({nowarn_unused_function, yeccpars2_72/7}). +yeccpars2_72(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_72_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_73/7}). +-compile({nowarn_unused_function, yeccpars2_73/7}). +yeccpars2_73(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 79, Ss, Stack, T, Ts, Tzr); +yeccpars2_73(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_73_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_74/7}). +-compile({nowarn_unused_function, yeccpars2_74/7}). +yeccpars2_74(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_74_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_75/7}). +-compile({nowarn_unused_function, yeccpars2_75/7}). +yeccpars2_75(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 78, Ss, Stack, T, Ts, Tzr); +yeccpars2_75(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_75_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_76/7}). +-compile({nowarn_unused_function, yeccpars2_76/7}). +yeccpars2_76(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 77, Ss, Stack, T, Ts, Tzr); +yeccpars2_76(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_76_(Stack), + yeccgoto_open_curly(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_77/7}). +-compile({nowarn_unused_function, yeccpars2_77/7}). +yeccpars2_77(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_77_(Stack), + yeccgoto_open_curly(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_78/7}). +-compile({nowarn_unused_function, yeccpars2_78/7}). +yeccpars2_78(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_78_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_79/7}). +-compile({nowarn_unused_function, yeccpars2_79/7}). +yeccpars2_79(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_79_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_80/7}). +-compile({nowarn_unused_function, yeccpars2_80/7}). +yeccpars2_80(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_80_(Stack), + yeccgoto_fn_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_81/7}). +-compile({nowarn_unused_function, yeccpars2_81/7}). +yeccpars2_81(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_81_(Stack), + yeccgoto_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_82/7}). +-compile({nowarn_unused_function, yeccpars2_82/7}). +yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_82_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_83/7}). +-compile({nowarn_unused_function, yeccpars2_83/7}). +yeccpars2_83(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_83_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_84/7}). +-compile({nowarn_unused_function, yeccpars2_84/7}). +yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_84_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_85: see yeccpars2_2 + +yeccpars2_86(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_87/7}). +-compile({nowarn_unused_function, yeccpars2_87/7}). +yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_87_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_88: see yeccpars2_2 + +%% yeccpars2_89: see yeccpars2_2 + +%% yeccpars2_90: see yeccpars2_2 + +%% yeccpars2_91: see yeccpars2_2 + +%% yeccpars2_92: see yeccpars2_2 + +%% yeccpars2_93: see yeccpars2_2 + +%% yeccpars2_94: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_95/7}). +-compile({nowarn_unused_function, yeccpars2_95/7}). +yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_95_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_96: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_97/7}). +-compile({nowarn_unused_function, yeccpars2_97/7}). +yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_97_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_98: see yeccpars2_2 + +%% yeccpars2_99: see yeccpars2_2 + +%% yeccpars2_100: see yeccpars2_2 + +%% yeccpars2_101: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_102/7}). +-compile({nowarn_unused_function, yeccpars2_102/7}). +yeccpars2_102(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 163, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 164, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 165, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 166, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 167, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 168, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_103: see yeccpars2_2 + +%% yeccpars2_104: see yeccpars2_2 + +%% yeccpars2_105: see yeccpars2_2 + +%% yeccpars2_106: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_107/7}). +-compile({nowarn_unused_function, yeccpars2_107/7}). +yeccpars2_107(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 145, Ss, Stack, T, Ts, Tzr); +yeccpars2_107(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_107_(Stack), + yeccgoto_dot_op(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_108/7}). +-compile({nowarn_unused_function, yeccpars2_108/7}). +yeccpars2_108(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 144, Ss, Stack, T, Ts, Tzr); +yeccpars2_108(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_108_(Stack), + yeccgoto_and_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_109/7}). +-compile({nowarn_unused_function, yeccpars2_109/7}). +yeccpars2_109(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 143, Ss, Stack, T, Ts, Tzr); +yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_109_(Stack), + yeccgoto_arrow_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_110/7}). +-compile({nowarn_unused_function, yeccpars2_110/7}). +yeccpars2_110(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 142, Ss, Stack, T, Ts, Tzr); +yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_110_(Stack), + yeccgoto_comp_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_111/7}). +-compile({nowarn_unused_function, yeccpars2_111/7}). +yeccpars2_111(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 141, Ss, Stack, T, Ts, Tzr); +yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_111_(Stack), + yeccgoto_concat_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_112/7}). +-compile({nowarn_unused_function, yeccpars2_112/7}). +yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_112_(Stack), + yeccgoto_dot_call_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_113/7}). +-compile({nowarn_unused_function, yeccpars2_113/7}). +yeccpars2_113(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 140, Ss, Stack, T, Ts, Tzr); +yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_113_(Stack), + yeccgoto_dual_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_114/7}). +-compile({nowarn_unused_function, yeccpars2_114/7}). +yeccpars2_114(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 139, Ss, Stack, T, Ts, Tzr); +yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_114_(Stack), + yeccgoto_in_match_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_115/7}). +-compile({nowarn_unused_function, yeccpars2_115/7}). +yeccpars2_115(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 138, Ss, Stack, T, Ts, Tzr); +yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_115_(Stack), + yeccgoto_in_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_116/7}). +-compile({nowarn_unused_function, yeccpars2_116/7}). +yeccpars2_116(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 137, Ss, Stack, T, Ts, Tzr); +yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_116_(Stack), + yeccgoto_match_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_117/7}). +-compile({nowarn_unused_function, yeccpars2_117/7}). +yeccpars2_117(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 136, Ss, Stack, T, Ts, Tzr); +yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_117_(Stack), + yeccgoto_mult_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_118/7}). +-compile({nowarn_unused_function, yeccpars2_118/7}). +yeccpars2_118(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 135, Ss, Stack, T, Ts, Tzr); +yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_118_(Stack), + yeccgoto_or_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_119/7}). +-compile({nowarn_unused_function, yeccpars2_119/7}). +yeccpars2_119(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 134, Ss, Stack, T, Ts, Tzr); +yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_119_(Stack), + yeccgoto_pipe_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_120/7}). +-compile({nowarn_unused_function, yeccpars2_120/7}). +yeccpars2_120(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 133, Ss, Stack, T, Ts, Tzr); +yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_120_(Stack), + yeccgoto_power_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_121/7}). +-compile({nowarn_unused_function, yeccpars2_121/7}). +yeccpars2_121(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 132, Ss, Stack, T, Ts, Tzr); +yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_121_(Stack), + yeccgoto_range_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_122/7}). +-compile({nowarn_unused_function, yeccpars2_122/7}). +yeccpars2_122(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr); +yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_122_(Stack), + yeccgoto_rel_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_123/7}). +-compile({nowarn_unused_function, yeccpars2_123/7}). +yeccpars2_123(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr); +yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_123_(Stack), + yeccgoto_ternary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_124/7}). +-compile({nowarn_unused_function, yeccpars2_124/7}). +yeccpars2_124(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 129, Ss, Stack, T, Ts, Tzr); +yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_124_(Stack), + yeccgoto_type_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_125/7}). +-compile({nowarn_unused_function, yeccpars2_125/7}). +yeccpars2_125(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 128, Ss, Stack, T, Ts, Tzr); +yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_125_(Stack), + yeccgoto_when_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_126/7}). +-compile({nowarn_unused_function, yeccpars2_126/7}). +yeccpars2_126(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 127, Ss, Stack, T, Ts, Tzr); +yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_126_(Stack), + yeccgoto_xor_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_127/7}). +-compile({nowarn_unused_function, yeccpars2_127/7}). +yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_127_(Stack), + yeccgoto_xor_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_128/7}). +-compile({nowarn_unused_function, yeccpars2_128/7}). +yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_128_(Stack), + yeccgoto_when_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_129/7}). +-compile({nowarn_unused_function, yeccpars2_129/7}). +yeccpars2_129(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_129_(Stack), + yeccgoto_type_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_130/7}). +-compile({nowarn_unused_function, yeccpars2_130/7}). +yeccpars2_130(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_130_(Stack), + yeccgoto_ternary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_131/7}). +-compile({nowarn_unused_function, yeccpars2_131/7}). +yeccpars2_131(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_131_(Stack), + yeccgoto_rel_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_132/7}). +-compile({nowarn_unused_function, yeccpars2_132/7}). +yeccpars2_132(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_132_(Stack), + yeccgoto_range_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_133/7}). +-compile({nowarn_unused_function, yeccpars2_133/7}). +yeccpars2_133(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_133_(Stack), + yeccgoto_power_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_134/7}). +-compile({nowarn_unused_function, yeccpars2_134/7}). +yeccpars2_134(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_134_(Stack), + yeccgoto_pipe_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_135/7}). +-compile({nowarn_unused_function, yeccpars2_135/7}). +yeccpars2_135(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_135_(Stack), + yeccgoto_or_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_136/7}). +-compile({nowarn_unused_function, yeccpars2_136/7}). +yeccpars2_136(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_136_(Stack), + yeccgoto_mult_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_137/7}). +-compile({nowarn_unused_function, yeccpars2_137/7}). +yeccpars2_137(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_137_(Stack), + yeccgoto_match_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_138/7}). +-compile({nowarn_unused_function, yeccpars2_138/7}). +yeccpars2_138(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_138_(Stack), + yeccgoto_in_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_139/7}). +-compile({nowarn_unused_function, yeccpars2_139/7}). +yeccpars2_139(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_139_(Stack), + yeccgoto_in_match_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_140/7}). +-compile({nowarn_unused_function, yeccpars2_140/7}). +yeccpars2_140(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_140_(Stack), + yeccgoto_dual_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_141/7}). +-compile({nowarn_unused_function, yeccpars2_141/7}). +yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_141_(Stack), + yeccgoto_concat_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_142/7}). +-compile({nowarn_unused_function, yeccpars2_142/7}). +yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_142_(Stack), + yeccgoto_comp_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_143/7}). +-compile({nowarn_unused_function, yeccpars2_143/7}). +yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_143_(Stack), + yeccgoto_arrow_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_144/7}). +-compile({nowarn_unused_function, yeccpars2_144/7}). +yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_144_(Stack), + yeccgoto_and_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_145/7}). +-compile({nowarn_unused_function, yeccpars2_145/7}). +yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_145_(Stack), + yeccgoto_dot_op(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_146/7}). +-compile({nowarn_unused_function, yeccpars2_146/7}). +yeccpars2_146(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_146_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_147/7}). +-compile({nowarn_unused_function, yeccpars2_147/7}). +yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_147_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_148/7}). +-compile({nowarn_unused_function, yeccpars2_148/7}). +yeccpars2_148(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_148_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_149/7}). +-compile({nowarn_unused_function, yeccpars2_149/7}). +yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_149_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_150/7}). +-compile({nowarn_unused_function, yeccpars2_150/7}). +yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_150_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_151/7}). +-compile({nowarn_unused_function, yeccpars2_151/7}). +yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_151_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_152/7}). +-compile({nowarn_unused_function, yeccpars2_152/7}). +yeccpars2_152(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_152_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_153/7}). +-compile({nowarn_unused_function, yeccpars2_153/7}). +yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_153_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_154/7}). +-compile({nowarn_unused_function, yeccpars2_154/7}). +yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_154_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_155/7}). +-compile({nowarn_unused_function, yeccpars2_155/7}). +yeccpars2_155(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_155_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_156/7}). +-compile({nowarn_unused_function, yeccpars2_156/7}). +yeccpars2_156(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_156_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_157/7}). +-compile({nowarn_unused_function, yeccpars2_157/7}). +yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_157_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_158/7}). +-compile({nowarn_unused_function, yeccpars2_158/7}). +yeccpars2_158(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_158_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_159/7}). +-compile({nowarn_unused_function, yeccpars2_159/7}). +yeccpars2_159(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_159_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_160/7}). +-compile({nowarn_unused_function, yeccpars2_160/7}). +yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_160_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_161/7}). +-compile({nowarn_unused_function, yeccpars2_161/7}). +yeccpars2_161(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_161_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_162(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_163/7}). +-compile({nowarn_unused_function, yeccpars2_163/7}). +yeccpars2_163(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_163_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_164/7}). +-compile({nowarn_unused_function, yeccpars2_164/7}). +yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_164_(Stack), + yeccgoto_dot_bracket_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_165/7}). +-compile({nowarn_unused_function, yeccpars2_165/7}). +yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_165_(Stack), + yeccgoto_dot_do_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_166/7}). +-compile({nowarn_unused_function, yeccpars2_166/7}). +yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_166_(Stack), + yeccgoto_dot_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_167/7}). +-compile({nowarn_unused_function, yeccpars2_167/7}). +yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_167_(Stack), + yeccgoto_dot_op_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_168/7}). +-compile({nowarn_unused_function, yeccpars2_168/7}). +yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_168_(Stack), + yeccgoto_dot_paren_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_169/7}). +-compile({nowarn_unused_function, yeccpars2_169/7}). +yeccpars2_169(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_169_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_170/7}). +-compile({nowarn_unused_function, yeccpars2_170/7}). +yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_170_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_171/7}). +-compile({nowarn_unused_function, yeccpars2_171/7}). +yeccpars2_171(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_171_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_172/7}). +-compile({nowarn_unused_function, yeccpars2_172/7}). +yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_172_(Stack), + yeccgoto_container_args_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_173/7}). +-compile({nowarn_unused_function, yeccpars2_173/7}). +yeccpars2_173(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr); +yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_173_(Stack), + yeccgoto_container_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_174/7}). +-compile({nowarn_unused_function, yeccpars2_174/7}). +yeccpars2_174(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr); +yeccpars2_174(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr); +yeccpars2_174(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_175/7}). +-compile({nowarn_unused_function, yeccpars2_175/7}). +yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_175_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_176/7}). +-compile({nowarn_unused_function, yeccpars2_176/7}). +yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_176_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_177/7}). +-compile({nowarn_unused_function, yeccpars2_177/7}). +yeccpars2_177(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr); +yeccpars2_177(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_178/7}). +-compile({nowarn_unused_function, yeccpars2_178/7}). +yeccpars2_178(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_178_(Stack), + yeccgoto_close_curly(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_179/7}). +-compile({nowarn_unused_function, yeccpars2_179/7}). +yeccpars2_179(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_179_(Stack), + yeccgoto_close_curly(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_180/7}). +-compile({nowarn_unused_function, yeccpars2_180/7}). +yeccpars2_180(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_180_(Stack), + yeccgoto_container_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_181: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_182/7}). +-compile({nowarn_unused_function, yeccpars2_182/7}). +yeccpars2_182(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_182_(Stack), + yeccgoto_container_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_183/7}). +-compile({nowarn_unused_function, yeccpars2_183/7}). +yeccpars2_183(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr); +yeccpars2_183(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_183_(Stack), + yeccgoto_kw_data(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_184/7}). +-compile({nowarn_unused_function, yeccpars2_184/7}). +yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_184_(Stack), + yeccgoto_container_args_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_185/7}). +-compile({nowarn_unused_function, yeccpars2_185/7}). +yeccpars2_185(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 190, Ss, Stack, T, Ts, Tzr); +yeccpars2_185(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_185_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_186/7}). +-compile({nowarn_unused_function, yeccpars2_186/7}). +yeccpars2_186(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr); +yeccpars2_186(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_186_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_187/7}). +-compile({nowarn_unused_function, yeccpars2_187/7}). +yeccpars2_187(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr); +yeccpars2_187(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_187_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_188/7}). +-compile({nowarn_unused_function, yeccpars2_188/7}). +yeccpars2_188(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_188_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_189/7}). +-compile({nowarn_unused_function, yeccpars2_189/7}). +yeccpars2_189(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_189_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_190/7}). +-compile({nowarn_unused_function, yeccpars2_190/7}). +yeccpars2_190(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_190_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_191/7}). +-compile({nowarn_unused_function, yeccpars2_191/7}). +yeccpars2_191(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_191_(Stack), + yeccgoto_kw_data(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_192(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_193/7}). +-compile({nowarn_unused_function, yeccpars2_193/7}). +yeccpars2_193(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_193_(Stack), + yeccgoto_kw_data(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_194: see yeccpars2_2 + +yeccpars2_195(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_196/7}). +-compile({nowarn_unused_function, yeccpars2_196/7}). +yeccpars2_196(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_196_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_197/7}). +-compile({nowarn_unused_function, yeccpars2_197/7}). +yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_197_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_198: see yeccpars2_29 + +%% yeccpars2_199: see yeccpars2_192 + +%% yeccpars2_200: see yeccpars2_192 + +-dialyzer({nowarn_function, yeccpars2_201/7}). +-compile({nowarn_unused_function, yeccpars2_201/7}). +yeccpars2_201(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_201_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_202/7}). +-compile({nowarn_unused_function, yeccpars2_202/7}). +yeccpars2_202(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_202_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_203: see yeccpars2_192 + +%% yeccpars2_204: see yeccpars2_192 + +%% yeccpars2_205: see yeccpars2_192 + +%% yeccpars2_206: see yeccpars2_192 + +%% yeccpars2_207: see yeccpars2_192 + +%% yeccpars2_208: see yeccpars2_192 + +%% yeccpars2_209: see yeccpars2_192 + +%% yeccpars2_210: see yeccpars2_192 + +%% yeccpars2_211: see yeccpars2_192 + +%% yeccpars2_212: see yeccpars2_192 + +%% yeccpars2_213: see yeccpars2_192 + +%% yeccpars2_214: see yeccpars2_192 + +%% yeccpars2_215: see yeccpars2_192 + +%% yeccpars2_216: see yeccpars2_192 + +%% yeccpars2_217: see yeccpars2_192 + +%% yeccpars2_218: see yeccpars2_192 + +%% yeccpars2_219: see yeccpars2_192 + +%% yeccpars2_220: see yeccpars2_192 + +-dialyzer({nowarn_function, yeccpars2_221/7}). +-compile({nowarn_unused_function, yeccpars2_221/7}). +yeccpars2_221(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_221_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_222/7}). +-compile({nowarn_unused_function, yeccpars2_222/7}). +yeccpars2_222(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_222_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_223/7}). +-compile({nowarn_unused_function, yeccpars2_223/7}). +yeccpars2_223(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_223_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_224/7}). +-compile({nowarn_unused_function, yeccpars2_224/7}). +yeccpars2_224(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_224_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_225/7}). +-compile({nowarn_unused_function, yeccpars2_225/7}). +yeccpars2_225(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_225_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_226/7}). +-compile({nowarn_unused_function, yeccpars2_226/7}). +yeccpars2_226(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_226_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_227/7}). +-compile({nowarn_unused_function, yeccpars2_227/7}). +yeccpars2_227(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_227_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_228/7}). +-compile({nowarn_unused_function, yeccpars2_228/7}). +yeccpars2_228(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_228_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_229/7}). +-compile({nowarn_unused_function, yeccpars2_229/7}). +yeccpars2_229(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_229_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_230/7}). +-compile({nowarn_unused_function, yeccpars2_230/7}). +yeccpars2_230(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_230_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_231/7}). +-compile({nowarn_unused_function, yeccpars2_231/7}). +yeccpars2_231(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_231_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_232/7}). +-compile({nowarn_unused_function, yeccpars2_232/7}). +yeccpars2_232(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_232(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_232(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_232_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_233/7}). +-compile({nowarn_unused_function, yeccpars2_233/7}). +yeccpars2_233(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_233_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_234/7}). +-compile({nowarn_unused_function, yeccpars2_234/7}). +yeccpars2_234(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_234_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_235/7}). +-compile({nowarn_unused_function, yeccpars2_235/7}). +yeccpars2_235(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_235_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_236/7}). +-compile({nowarn_unused_function, yeccpars2_236/7}). +yeccpars2_236(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_236_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_237/7}). +-compile({nowarn_unused_function, yeccpars2_237/7}). +yeccpars2_237(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_237_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_238/7}). +-compile({nowarn_unused_function, yeccpars2_238/7}). +yeccpars2_238(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_238_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_239/7}). +-compile({nowarn_unused_function, yeccpars2_239/7}). +yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_239_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_240: see yeccpars2_30 + +-dialyzer({nowarn_function, yeccpars2_241/7}). +-compile({nowarn_unused_function, yeccpars2_241/7}). +yeccpars2_241(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_241(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr); +yeccpars2_241(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_241_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_242: see yeccpars2_86 + +-dialyzer({nowarn_function, yeccpars2_243/7}). +-compile({nowarn_unused_function, yeccpars2_243/7}). +yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_243_(Stack), + yeccgoto_bracket_at_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_244/7}). +-compile({nowarn_unused_function, yeccpars2_244/7}). +yeccpars2_244(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_244_(Stack), + yeccgoto_sub_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_245/7}). +-compile({nowarn_unused_function, yeccpars2_245/7}). +yeccpars2_245(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr); +yeccpars2_245(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 250, Ss, Stack, T, Ts, Tzr); +yeccpars2_245(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_246(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 248, Ss, Stack, T, Ts, Tzr); +yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_247/7}). +-compile({nowarn_unused_function, yeccpars2_247/7}). +yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_247_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_248(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 250, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_249/7}). +-compile({nowarn_unused_function, yeccpars2_249/7}). +yeccpars2_249(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_249_(Stack), + yeccgoto_close_bracket(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_250/7}). +-compile({nowarn_unused_function, yeccpars2_250/7}). +yeccpars2_250(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 251, Ss, Stack, T, Ts, Tzr); +yeccpars2_250(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_251/7}). +-compile({nowarn_unused_function, yeccpars2_251/7}). +yeccpars2_251(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_251_(Stack), + yeccgoto_close_bracket(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_252: see yeccpars2_245 + +-dialyzer({nowarn_function, yeccpars2_253/7}). +-compile({nowarn_unused_function, yeccpars2_253/7}). +yeccpars2_253(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_253_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_254/7}). +-compile({nowarn_unused_function, yeccpars2_254/7}). +yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_254_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_255/7}). +-compile({nowarn_unused_function, yeccpars2_255/7}). +yeccpars2_255(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_255_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_256/7}). +-compile({nowarn_unused_function, yeccpars2_256/7}). +yeccpars2_256(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_256_(Stack), + yeccgoto_bracket_at_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_257/7}). +-compile({nowarn_unused_function, yeccpars2_257/7}). +yeccpars2_257(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_257_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_258(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 268, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_259/7}). +-compile({nowarn_unused_function, yeccpars2_259/7}). +yeccpars2_259(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_259(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_259_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_260/7}). +-compile({nowarn_unused_function, yeccpars2_260/7}). +yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_260_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_261/7}). +-compile({nowarn_unused_function, yeccpars2_261/7}). +yeccpars2_261(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_261_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_262/7}). +-compile({nowarn_unused_function, yeccpars2_262/7}). +yeccpars2_262(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_262(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_262(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_262_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_263/7}). +-compile({nowarn_unused_function, yeccpars2_263/7}). +yeccpars2_263(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_263_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_264/7}). +-compile({nowarn_unused_function, yeccpars2_264/7}). +yeccpars2_264(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_264(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_264(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_265/7}). +-compile({nowarn_unused_function, yeccpars2_265/7}). +yeccpars2_265(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 278, Ss, Stack, T, Ts, Tzr); +yeccpars2_265(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_265_(Stack), + yeccgoto_kw_call(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_266/7}). +-compile({nowarn_unused_function, yeccpars2_266/7}). +yeccpars2_266(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_266_(Stack), + yeccgoto_call_args_parens_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_267(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 271, Ss, Stack, T, Ts, Tzr); +yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_268/7}). +-compile({nowarn_unused_function, yeccpars2_268/7}). +yeccpars2_268(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_268_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_269/7}). +-compile({nowarn_unused_function, yeccpars2_269/7}). +yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_269_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_270/7}). +-compile({nowarn_unused_function, yeccpars2_270/7}). +yeccpars2_270(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_270_(Stack), + yeccgoto_close_paren(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_271: see yeccpars2_86 + +-dialyzer({nowarn_function, yeccpars2_272/7}). +-compile({nowarn_unused_function, yeccpars2_272/7}). +yeccpars2_272(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr); +yeccpars2_272(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_273/7}). +-compile({nowarn_unused_function, yeccpars2_273/7}). +yeccpars2_273(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_273_(Stack), + yeccgoto_close_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_274/7}). +-compile({nowarn_unused_function, yeccpars2_274/7}). +yeccpars2_274(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_274_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_275: see yeccpars2_264 + +-dialyzer({nowarn_function, yeccpars2_276/7}). +-compile({nowarn_unused_function, yeccpars2_276/7}). +yeccpars2_276(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_276_(Stack), + yeccgoto_call_args_parens_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_277/7}). +-compile({nowarn_unused_function, yeccpars2_277/7}). +yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_277_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_278/7}). +-compile({nowarn_unused_function, yeccpars2_278/7}). +yeccpars2_278(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_278_(Stack), + yeccgoto_kw_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_279/7}). +-compile({nowarn_unused_function, yeccpars2_279/7}). +yeccpars2_279(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_279_(Stack), + yeccgoto_kw_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_280/7}). +-compile({nowarn_unused_function, yeccpars2_280/7}). +yeccpars2_280(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_280_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_281/7}). +-compile({nowarn_unused_function, yeccpars2_281/7}). +yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_281_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_282/7}). +-compile({nowarn_unused_function, yeccpars2_282/7}). +yeccpars2_282(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_282_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_283(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_284/7}). +-compile({nowarn_unused_function, yeccpars2_284/7}). +yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_284_(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_285/7}). +-compile({nowarn_unused_function, yeccpars2_285/7}). +yeccpars2_285(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 287, Ss, Stack, T, Ts, Tzr); +yeccpars2_285(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_285_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_286/7}). +-compile({nowarn_unused_function, yeccpars2_286/7}). +yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_286_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_287: see yeccpars2_195 + +-dialyzer({nowarn_function, yeccpars2_288/7}). +-compile({nowarn_unused_function, yeccpars2_288/7}). +yeccpars2_288(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_288_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_289/7}). +-compile({nowarn_unused_function, yeccpars2_289/7}). +yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_289_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_290: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_291/7}). +-compile({nowarn_unused_function, yeccpars2_291/7}). +yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_291_(Stack), + yeccgoto_call_args_no_parens_kw_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_292/7}). +-compile({nowarn_unused_function, yeccpars2_292/7}). +yeccpars2_292(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_292_(Stack), + yeccgoto_call_args_no_parens_kw_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_293: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_294/7}). +-compile({nowarn_unused_function, yeccpars2_294/7}). +yeccpars2_294(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_294_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_295: see yeccpars2_283 + +%% yeccpars2_296: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_297/7}). +-compile({nowarn_unused_function, yeccpars2_297/7}). +yeccpars2_297(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_297_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_298/7}). +-compile({nowarn_unused_function, yeccpars2_298/7}). +yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_298_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_299/7}). +-compile({nowarn_unused_function, yeccpars2_299/7}). +yeccpars2_299(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_299_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_300: see yeccpars2_283 + +%% yeccpars2_301: see yeccpars2_26 + +%% yeccpars2_302: see yeccpars2_283 + +%% yeccpars2_303: see yeccpars2_283 + +%% yeccpars2_304: see yeccpars2_283 + +%% yeccpars2_305: see yeccpars2_283 + +%% yeccpars2_306: see yeccpars2_283 + +%% yeccpars2_307: see yeccpars2_283 + +%% yeccpars2_308: see yeccpars2_283 + +%% yeccpars2_309: see yeccpars2_283 + +%% yeccpars2_310: see yeccpars2_283 + +%% yeccpars2_311: see yeccpars2_283 + +%% yeccpars2_312: see yeccpars2_283 + +%% yeccpars2_313: see yeccpars2_283 + +%% yeccpars2_314: see yeccpars2_283 + +%% yeccpars2_315: see yeccpars2_283 + +%% yeccpars2_316: see yeccpars2_283 + +%% yeccpars2_317: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_318/7}). +-compile({nowarn_unused_function, yeccpars2_318/7}). +yeccpars2_318(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_318_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_319/7}). +-compile({nowarn_unused_function, yeccpars2_319/7}). +yeccpars2_319(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_319_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_320/7}). +-compile({nowarn_unused_function, yeccpars2_320/7}). +yeccpars2_320(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_320_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_321/7}). +-compile({nowarn_unused_function, yeccpars2_321/7}). +yeccpars2_321(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_321_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_322/7}). +-compile({nowarn_unused_function, yeccpars2_322/7}). +yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_322_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_323/7}). +-compile({nowarn_unused_function, yeccpars2_323/7}). +yeccpars2_323(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_323_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_324/7}). +-compile({nowarn_unused_function, yeccpars2_324/7}). +yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_324_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_325/7}). +-compile({nowarn_unused_function, yeccpars2_325/7}). +yeccpars2_325(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_325_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_326/7}). +-compile({nowarn_unused_function, yeccpars2_326/7}). +yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_326_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_327/7}). +-compile({nowarn_unused_function, yeccpars2_327/7}). +yeccpars2_327(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_327_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_328/7}). +-compile({nowarn_unused_function, yeccpars2_328/7}). +yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_328_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_329/7}). +-compile({nowarn_unused_function, yeccpars2_329/7}). +yeccpars2_329(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_329_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_330/7}). +-compile({nowarn_unused_function, yeccpars2_330/7}). +yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_330_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_331/7}). +-compile({nowarn_unused_function, yeccpars2_331/7}). +yeccpars2_331(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_331_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_332/7}). +-compile({nowarn_unused_function, yeccpars2_332/7}). +yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_332_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_333/7}). +-compile({nowarn_unused_function, yeccpars2_333/7}). +yeccpars2_333(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_333_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_334/7}). +-compile({nowarn_unused_function, yeccpars2_334/7}). +yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_334_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_335/7}). +-compile({nowarn_unused_function, yeccpars2_335/7}). +yeccpars2_335(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_335_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_336/7}). +-compile({nowarn_unused_function, yeccpars2_336/7}). +yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_336_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_337/7}). +-compile({nowarn_unused_function, yeccpars2_337/7}). +yeccpars2_337(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_337(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_337(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_337_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_338/7}). +-compile({nowarn_unused_function, yeccpars2_338/7}). +yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_338_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_339/7}). +-compile({nowarn_unused_function, yeccpars2_339/7}). +yeccpars2_339(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_339_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_340/7}). +-compile({nowarn_unused_function, yeccpars2_340/7}). +yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_340_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_341/7}). +-compile({nowarn_unused_function, yeccpars2_341/7}). +yeccpars2_341(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_341_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_342/7}). +-compile({nowarn_unused_function, yeccpars2_342/7}). +yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_342_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_343/7}). +-compile({nowarn_unused_function, yeccpars2_343/7}). +yeccpars2_343(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_343_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_344/7}). +-compile({nowarn_unused_function, yeccpars2_344/7}). +yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_344_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_345/7}). +-compile({nowarn_unused_function, yeccpars2_345/7}). +yeccpars2_345(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_345_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_346/7}). +-compile({nowarn_unused_function, yeccpars2_346/7}). +yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_346_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_347/7}). +-compile({nowarn_unused_function, yeccpars2_347/7}). +yeccpars2_347(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_347_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_348/7}). +-compile({nowarn_unused_function, yeccpars2_348/7}). +yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_348_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_349/7}). +-compile({nowarn_unused_function, yeccpars2_349/7}). +yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_349_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_350/7}). +-compile({nowarn_unused_function, yeccpars2_350/7}). +yeccpars2_350(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_350_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_351/7}). +-compile({nowarn_unused_function, yeccpars2_351/7}). +yeccpars2_351(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_351_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_352/7}). +-compile({nowarn_unused_function, yeccpars2_352/7}). +yeccpars2_352(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_352_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_353/7}). +-compile({nowarn_unused_function, yeccpars2_353/7}). +yeccpars2_353(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_353_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_354/7}). +-compile({nowarn_unused_function, yeccpars2_354/7}). +yeccpars2_354(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_354_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_355: see yeccpars2_6 + +-dialyzer({nowarn_function, yeccpars2_356/7}). +-compile({nowarn_unused_function, yeccpars2_356/7}). +yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_356_(Stack), + yeccgoto_call_args_no_parens_ambig(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_357/7}). +-compile({nowarn_unused_function, yeccpars2_357/7}). +yeccpars2_357(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 367, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_357_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_358/7}). +-compile({nowarn_unused_function, yeccpars2_358/7}). +yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_358_(Stack), + yeccgoto_no_parens_many_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_359/7}). +-compile({nowarn_unused_function, yeccpars2_359/7}). +yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_359_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_360/7}). +-compile({nowarn_unused_function, yeccpars2_360/7}). +yeccpars2_360(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 362, Ss, Stack, T, Ts, Tzr); +yeccpars2_360(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_360_(Stack), + yeccgoto_call_args_no_parens_many(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_361/7}). +-compile({nowarn_unused_function, yeccpars2_361/7}). +yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_361_(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_362: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_363/7}). +-compile({nowarn_unused_function, yeccpars2_363/7}). +yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_363_(Stack), + yeccgoto_call_args_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_364/7}). +-compile({nowarn_unused_function, yeccpars2_364/7}). +yeccpars2_364(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_364_(Stack), + yeccgoto_call_args_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_365/7}). +-compile({nowarn_unused_function, yeccpars2_365/7}). +yeccpars2_365(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_365_(Stack), + yeccgoto_call_args_no_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_366/7}). +-compile({nowarn_unused_function, yeccpars2_366/7}). +yeccpars2_366(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_366_(Stack), + yeccgoto_call_args_no_parens_comma_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_367: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_368/7}). +-compile({nowarn_unused_function, yeccpars2_368/7}). +yeccpars2_368(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_368_(Stack), + yeccgoto_call_args_no_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_369/7}). +-compile({nowarn_unused_function, yeccpars2_369/7}). +yeccpars2_369(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_369_(Stack), + yeccgoto_call_args_no_parens_comma_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_370/7}). +-compile({nowarn_unused_function, yeccpars2_370/7}). +yeccpars2_370(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_370(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 410, Ss, Stack, T, Ts, Tzr); +yeccpars2_370(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_371/7}). +-compile({nowarn_unused_function, yeccpars2_371/7}). +yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_371_(Stack), + yeccgoto_stab_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_372/7}). +-compile({nowarn_unused_function, yeccpars2_372/7}). +yeccpars2_372(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_372_(Stack), + yeccgoto_stab_op_eol_and_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_373/7}). +-compile({nowarn_unused_function, yeccpars2_373/7}). +yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_373_(Stack), + yeccgoto_stab(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_374/7}). +-compile({nowarn_unused_function, yeccpars2_374/7}). +yeccpars2_374(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 407, Ss, Stack, T, Ts, Tzr); +yeccpars2_374(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_375/7}). +-compile({nowarn_unused_function, yeccpars2_375/7}). +yeccpars2_375(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_375(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_375(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_375_(Stack), + yeccgoto_stab_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_376: see yeccpars2_6 + +-dialyzer({nowarn_function, yeccpars2_377/7}). +-compile({nowarn_unused_function, yeccpars2_377/7}). +yeccpars2_377(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_377_)'(Stack), + yeccgoto_expr(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_377_;'(Stack), + yeccgoto_expr(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_block_identifier(Stack), + yeccgoto_expr(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_end(Stack), + yeccgoto_expr(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_eol(Stack), + yeccgoto_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_(Stack), + yeccgoto_call_args_no_parens_ambig(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_378/7}). +-compile({nowarn_unused_function, yeccpars2_378/7}). +yeccpars2_378(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 367, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_378_)'(Stack), + yeccgoto_expr(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_378_;'(Stack), + yeccgoto_expr(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_block_identifier(Stack), + yeccgoto_expr(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_end(Stack), + yeccgoto_expr(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_eol(Stack), + yeccgoto_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_379/7}). +-compile({nowarn_unused_function, yeccpars2_379/7}). +yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_379_(Stack), + yeccgoto_stab_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_380/7}). +-compile({nowarn_unused_function, yeccpars2_380/7}). +yeccpars2_380(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_380(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 398, Ss, Stack, T, Ts, Tzr); +yeccpars2_380(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_380_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_381/7}). +-compile({nowarn_unused_function, yeccpars2_381/7}). +yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_381_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_382/7}). +-compile({nowarn_unused_function, yeccpars2_382/7}). +yeccpars2_382(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_382(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_382(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_382_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_383/7}). +-compile({nowarn_unused_function, yeccpars2_383/7}). +yeccpars2_383(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_383(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_383(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_383_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_384/7}). +-compile({nowarn_unused_function, yeccpars2_384/7}). +yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_384_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_385/7}). +-compile({nowarn_unused_function, yeccpars2_385/7}). +yeccpars2_385(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_385(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_386/7}). +-compile({nowarn_unused_function, yeccpars2_386/7}). +yeccpars2_386(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_386_(Stack), + yeccgoto_empty_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_387(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_388/7}). +-compile({nowarn_unused_function, yeccpars2_388/7}). +yeccpars2_388(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 389, Ss, Stack, T, Ts, Tzr); +yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_388_(Stack), + yeccgoto_stab_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_389/7}). +-compile({nowarn_unused_function, yeccpars2_389/7}). +yeccpars2_389(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_389_(Stack), + yeccgoto_stab_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_390/7}). +-compile({nowarn_unused_function, yeccpars2_390/7}). +yeccpars2_390(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 393, Ss, Stack, T, Ts, Tzr); +yeccpars2_390(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_391/7}). +-compile({nowarn_unused_function, yeccpars2_391/7}). +yeccpars2_391(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_391_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_392/7}). +-compile({nowarn_unused_function, yeccpars2_392/7}). +yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_392_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_393/7}). +-compile({nowarn_unused_function, yeccpars2_393/7}). +yeccpars2_393(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_393_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_394/7}). +-compile({nowarn_unused_function, yeccpars2_394/7}). +yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_394_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_395/7}). +-compile({nowarn_unused_function, yeccpars2_395/7}). +yeccpars2_395(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_395_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_396/7}). +-compile({nowarn_unused_function, yeccpars2_396/7}). +yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_396_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_397/7}). +-compile({nowarn_unused_function, yeccpars2_397/7}). +yeccpars2_397(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_397_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_398: see yeccpars2_2 + +%% yeccpars2_399: see yeccpars2_385 + +-dialyzer({nowarn_function, yeccpars2_400/7}). +-compile({nowarn_unused_function, yeccpars2_400/7}). +yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_400_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_401/7}). +-compile({nowarn_unused_function, yeccpars2_401/7}). +yeccpars2_401(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_401(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_401(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_401_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_402/7}). +-compile({nowarn_unused_function, yeccpars2_402/7}). +yeccpars2_402(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_402(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_402_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_403/7}). +-compile({nowarn_unused_function, yeccpars2_403/7}). +yeccpars2_403(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_403_(Stack), + yeccgoto_stab_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_404/7}). +-compile({nowarn_unused_function, yeccpars2_404/7}). +yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_404_(Stack), + yeccgoto_stab_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_405/7}). +-compile({nowarn_unused_function, yeccpars2_405/7}). +yeccpars2_405(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_405_(Stack), + yeccgoto_stab_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_406/7}). +-compile({nowarn_unused_function, yeccpars2_406/7}). +yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_406_(Stack), + yeccgoto_stab(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_407/7}). +-compile({nowarn_unused_function, yeccpars2_407/7}). +yeccpars2_407(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_407_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_408/7}). +-compile({nowarn_unused_function, yeccpars2_408/7}). +yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_408_(Stack), + yeccgoto_stab_op_eol_and_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_409/7}). +-compile({nowarn_unused_function, yeccpars2_409/7}). +yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_409_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_410: see yeccpars2_2 + +%% yeccpars2_411: see yeccpars2_385 + +-dialyzer({nowarn_function, yeccpars2_412/7}). +-compile({nowarn_unused_function, yeccpars2_412/7}). +yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_412_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_413/7}). +-compile({nowarn_unused_function, yeccpars2_413/7}). +yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_413_(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_414/7}). +-compile({nowarn_unused_function, yeccpars2_414/7}). +yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_414_(Stack), + yeccgoto_no_parens_many_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_415/7}). +-compile({nowarn_unused_function, yeccpars2_415/7}). +yeccpars2_415(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_415_(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_416/7}). +-compile({nowarn_unused_function, yeccpars2_416/7}). +yeccpars2_416(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_416_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_417/7}). +-compile({nowarn_unused_function, yeccpars2_417/7}). +yeccpars2_417(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_417(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_417(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_417_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_418/7}). +-compile({nowarn_unused_function, yeccpars2_418/7}). +yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_418_(Stack), + yeccgoto_kw_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_419/7}). +-compile({nowarn_unused_function, yeccpars2_419/7}). +yeccpars2_419(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_419(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_419(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_419_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_420/7}). +-compile({nowarn_unused_function, yeccpars2_420/7}). +yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_420_(Stack), + yeccgoto_kw_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_421/7}). +-compile({nowarn_unused_function, yeccpars2_421/7}). +yeccpars2_421(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_421(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_421(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_421_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_422/7}). +-compile({nowarn_unused_function, yeccpars2_422/7}). +yeccpars2_422(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_422_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_423/7}). +-compile({nowarn_unused_function, yeccpars2_423/7}). +yeccpars2_423(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_423_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_424/7}). +-compile({nowarn_unused_function, yeccpars2_424/7}). +yeccpars2_424(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_424_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_425/7}). +-compile({nowarn_unused_function, yeccpars2_425/7}). +yeccpars2_425(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_425_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_426/7}). +-compile({nowarn_unused_function, yeccpars2_426/7}). +yeccpars2_426(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_426_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_427/7}). +-compile({nowarn_unused_function, yeccpars2_427/7}). +yeccpars2_427(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_427_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_428/7}). +-compile({nowarn_unused_function, yeccpars2_428/7}). +yeccpars2_428(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_428_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_429/7}). +-compile({nowarn_unused_function, yeccpars2_429/7}). +yeccpars2_429(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_429(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_429_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_430/7}). +-compile({nowarn_unused_function, yeccpars2_430/7}). +yeccpars2_430(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_430_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_431/7}). +-compile({nowarn_unused_function, yeccpars2_431/7}). +yeccpars2_431(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_431_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_432/7}). +-compile({nowarn_unused_function, yeccpars2_432/7}). +yeccpars2_432(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_432_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_433/7}). +-compile({nowarn_unused_function, yeccpars2_433/7}). +yeccpars2_433(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_433_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_434/7}). +-compile({nowarn_unused_function, yeccpars2_434/7}). +yeccpars2_434(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_434_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_435/7}). +-compile({nowarn_unused_function, yeccpars2_435/7}). +yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_435_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_436/7}). +-compile({nowarn_unused_function, yeccpars2_436/7}). +yeccpars2_436(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_436(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_436(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_436_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_437/7}). +-compile({nowarn_unused_function, yeccpars2_437/7}). +yeccpars2_437(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_437_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_438/7}). +-compile({nowarn_unused_function, yeccpars2_438/7}). +yeccpars2_438(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_438_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_439/7}). +-compile({nowarn_unused_function, yeccpars2_439/7}). +yeccpars2_439(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_439_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_440/7}). +-compile({nowarn_unused_function, yeccpars2_440/7}). +yeccpars2_440(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_440_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_441/7}). +-compile({nowarn_unused_function, yeccpars2_441/7}). +yeccpars2_441(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_441_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_442/7}). +-compile({nowarn_unused_function, yeccpars2_442/7}). +yeccpars2_442(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_442_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_443/7}). +-compile({nowarn_unused_function, yeccpars2_443/7}). +yeccpars2_443(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_443_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_444/7}). +-compile({nowarn_unused_function, yeccpars2_444/7}). +yeccpars2_444(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_444_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_445/7}). +-compile({nowarn_unused_function, yeccpars2_445/7}). +yeccpars2_445(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_445_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_446/7}). +-compile({nowarn_unused_function, yeccpars2_446/7}). +yeccpars2_446(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_446_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_447/7}). +-compile({nowarn_unused_function, yeccpars2_447/7}). +yeccpars2_447(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_447_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_448/7}). +-compile({nowarn_unused_function, yeccpars2_448/7}). +yeccpars2_448(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_448_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_449/7}). +-compile({nowarn_unused_function, yeccpars2_449/7}). +yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_449_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_450/7}). +-compile({nowarn_unused_function, yeccpars2_450/7}). +yeccpars2_450(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_450_(Stack), + yeccgoto_capture_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_451/7}). +-compile({nowarn_unused_function, yeccpars2_451/7}). +yeccpars2_451(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_451_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_452/7}). +-compile({nowarn_unused_function, yeccpars2_452/7}). +yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_452_(Stack), + yeccgoto_at_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_453/7}). +-compile({nowarn_unused_function, yeccpars2_453/7}). +yeccpars2_453(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_453_(Stack), + yeccgoto_open_bracket(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_454/7}). +-compile({nowarn_unused_function, yeccpars2_454/7}). +yeccpars2_454(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_454_(Stack), + yeccgoto_open_bit(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_455/7}). +-compile({nowarn_unused_function, yeccpars2_455/7}). +yeccpars2_455(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_455_(Stack), + yeccgoto_open_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_456/7}). +-compile({nowarn_unused_function, yeccpars2_456/7}). +yeccpars2_456(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_456_(Stack), + yeccgoto_map_op(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_457: see yeccpars2_39 + +-dialyzer({nowarn_function, yeccpars2_458/7}). +-compile({nowarn_unused_function, yeccpars2_458/7}). +yeccpars2_458(_S, ',', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_,'(Stack), + yeccgoto_map_base_expr(hd(Ss), ',', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_458_eol(Stack), + yeccgoto_map_base_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, '{', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_{'(Stack), + yeccgoto_map_base_expr(hd(Ss), '{', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, '}', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_}'(Stack), + yeccgoto_map_base_expr(hd(Ss), '}', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_458_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_459(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_459(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_459(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_459/7}). +-compile({nowarn_unused_function, yeccpars2_459/7}). +yeccpars2_cont_459(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_460/7}). +-compile({nowarn_unused_function, yeccpars2_460/7}). +yeccpars2_460(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 467, Ss, Stack, T, Ts, Tzr); +yeccpars2_460(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_460(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_461: see yeccpars2_39 + +-dialyzer({nowarn_function, yeccpars2_462/7}). +-compile({nowarn_unused_function, yeccpars2_462/7}). +yeccpars2_462(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 462, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_462_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_463/7}). +-compile({nowarn_unused_function, yeccpars2_463/7}). +yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_463_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_464/7}). +-compile({nowarn_unused_function, yeccpars2_464/7}). +yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_464_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_465(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 485, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_466/7}). +-compile({nowarn_unused_function, yeccpars2_466/7}). +yeccpars2_466(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_466_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_467: see yeccpars2_16 + +-dialyzer({nowarn_function, yeccpars2_468/7}). +-compile({nowarn_unused_function, yeccpars2_468/7}). +yeccpars2_468(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_468_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_469(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_470(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_471(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_472/7}). +-compile({nowarn_unused_function, yeccpars2_472/7}). +yeccpars2_472(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_472_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_473/7}). +-compile({nowarn_unused_function, yeccpars2_473/7}). +yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_473_(Stack), + yeccgoto_assoc_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_474: see yeccpars2_174 + +%% yeccpars2_475: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_476/7}). +-compile({nowarn_unused_function, yeccpars2_476/7}). +yeccpars2_476(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_476_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_477: see yeccpars2_2 + +%% yeccpars2_478: see yeccpars2_470 + +%% yeccpars2_479: see yeccpars2_174 + +yeccpars2_480(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 551, Ss, Stack, T, Ts, Tzr); +yeccpars2_480(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_481/7}). +-compile({nowarn_unused_function, yeccpars2_481/7}). +yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_481_(Stack), + yeccgoto_assoc_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_482/7}). +-compile({nowarn_unused_function, yeccpars2_482/7}). +yeccpars2_482(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 497, Ss, Stack, T, Ts, Tzr); +yeccpars2_482(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_482_(Stack), + yeccgoto_assoc(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_483: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_484/7}). +-compile({nowarn_unused_function, yeccpars2_484/7}). +yeccpars2_484(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_484_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_485/7}). +-compile({nowarn_unused_function, yeccpars2_485/7}). +yeccpars2_485(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_485_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_486: see yeccpars2_470 + +%% yeccpars2_487: see yeccpars2_470 + +-dialyzer({nowarn_function, yeccpars2_488/7}). +-compile({nowarn_unused_function, yeccpars2_488/7}). +yeccpars2_488(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_488_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_489/7}). +-compile({nowarn_unused_function, yeccpars2_489/7}). +yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_489_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_490/7}). +-compile({nowarn_unused_function, yeccpars2_490/7}). +yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_490_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_491/7}). +-compile({nowarn_unused_function, yeccpars2_491/7}). +yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_491_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_492/7}). +-compile({nowarn_unused_function, yeccpars2_492/7}). +yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_492_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_493/7}). +-compile({nowarn_unused_function, yeccpars2_493/7}). +yeccpars2_493(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_493(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_493(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_493_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_494/7}). +-compile({nowarn_unused_function, yeccpars2_494/7}). +yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_494_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_495/7}). +-compile({nowarn_unused_function, yeccpars2_495/7}). +yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_495_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_496/7}). +-compile({nowarn_unused_function, yeccpars2_496/7}). +yeccpars2_496(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_496_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_497/7}). +-compile({nowarn_unused_function, yeccpars2_497/7}). +yeccpars2_497(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_497_(Stack), + yeccgoto_assoc(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_498: see yeccpars2_469 + +%% yeccpars2_499: see yeccpars2_471 + +%% yeccpars2_500: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_501/7}). +-compile({nowarn_unused_function, yeccpars2_501/7}). +yeccpars2_501(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_501_(Stack), + yeccgoto_assoc_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_502/7}). +-compile({nowarn_unused_function, yeccpars2_502/7}). +yeccpars2_502(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_502_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_503(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 527, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +%% yeccpars2_504: see yeccpars2_503 + +%% yeccpars2_505: see yeccpars2_503 + +%% yeccpars2_506: see yeccpars2_503 + +%% yeccpars2_507: see yeccpars2_503 + +%% yeccpars2_508: see yeccpars2_503 + +%% yeccpars2_509: see yeccpars2_503 + +%% yeccpars2_510: see yeccpars2_503 + +%% yeccpars2_511: see yeccpars2_503 + +%% yeccpars2_512: see yeccpars2_503 + +%% yeccpars2_513: see yeccpars2_503 + +%% yeccpars2_514: see yeccpars2_503 + +%% yeccpars2_515: see yeccpars2_503 + +%% yeccpars2_516: see yeccpars2_503 + +%% yeccpars2_517: see yeccpars2_503 + +%% yeccpars2_518: see yeccpars2_503 + +%% yeccpars2_519: see yeccpars2_503 + +%% yeccpars2_520: see yeccpars2_503 + +%% yeccpars2_521: see yeccpars2_503 + +-dialyzer({nowarn_function, yeccpars2_522/7}). +-compile({nowarn_unused_function, yeccpars2_522/7}). +yeccpars2_522(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 523, Ss, Stack, T, Ts, Tzr); +yeccpars2_522(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_522_(Stack), + yeccgoto_assoc_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_523/7}). +-compile({nowarn_unused_function, yeccpars2_523/7}). +yeccpars2_523(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_523_(Stack), + yeccgoto_assoc_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_524: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_525/7}). +-compile({nowarn_unused_function, yeccpars2_525/7}). +yeccpars2_525(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_525_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_526: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_527/7}). +-compile({nowarn_unused_function, yeccpars2_527/7}). +yeccpars2_527(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_527_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_528/7}). +-compile({nowarn_unused_function, yeccpars2_528/7}). +yeccpars2_528(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_528_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_529/7}). +-compile({nowarn_unused_function, yeccpars2_529/7}). +yeccpars2_529(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_529_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_530/7}). +-compile({nowarn_unused_function, yeccpars2_530/7}). +yeccpars2_530(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_530_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_531/7}). +-compile({nowarn_unused_function, yeccpars2_531/7}). +yeccpars2_531(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_531_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_532/7}). +-compile({nowarn_unused_function, yeccpars2_532/7}). +yeccpars2_532(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_532_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_533/7}). +-compile({nowarn_unused_function, yeccpars2_533/7}). +yeccpars2_533(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_533_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_534/7}). +-compile({nowarn_unused_function, yeccpars2_534/7}). +yeccpars2_534(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_534_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_535/7}). +-compile({nowarn_unused_function, yeccpars2_535/7}). +yeccpars2_535(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_535_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_536/7}). +-compile({nowarn_unused_function, yeccpars2_536/7}). +yeccpars2_536(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_536_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_537/7}). +-compile({nowarn_unused_function, yeccpars2_537/7}). +yeccpars2_537(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_537_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_538/7}). +-compile({nowarn_unused_function, yeccpars2_538/7}). +yeccpars2_538(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_538_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_539/7}). +-compile({nowarn_unused_function, yeccpars2_539/7}). +yeccpars2_539(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_539_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_540/7}). +-compile({nowarn_unused_function, yeccpars2_540/7}). +yeccpars2_540(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_540(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_540(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_540_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_541/7}). +-compile({nowarn_unused_function, yeccpars2_541/7}). +yeccpars2_541(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_541_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_542/7}). +-compile({nowarn_unused_function, yeccpars2_542/7}). +yeccpars2_542(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_542_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_543/7}). +-compile({nowarn_unused_function, yeccpars2_543/7}). +yeccpars2_543(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_543_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_544/7}). +-compile({nowarn_unused_function, yeccpars2_544/7}). +yeccpars2_544(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_544_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_545/7}). +-compile({nowarn_unused_function, yeccpars2_545/7}). +yeccpars2_545(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_545_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_546/7}). +-compile({nowarn_unused_function, yeccpars2_546/7}). +yeccpars2_546(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_546_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_547: see yeccpars2_503 + +-dialyzer({nowarn_function, yeccpars2_548/7}). +-compile({nowarn_unused_function, yeccpars2_548/7}). +yeccpars2_548(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_548_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_549/7}). +-compile({nowarn_unused_function, yeccpars2_549/7}). +yeccpars2_549(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_549_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_550/7}). +-compile({nowarn_unused_function, yeccpars2_550/7}). +yeccpars2_550(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_550_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_551(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_552/7}). +-compile({nowarn_unused_function, yeccpars2_552/7}). +yeccpars2_552(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_552_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_553/7}). +-compile({nowarn_unused_function, yeccpars2_553/7}). +yeccpars2_553(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_553_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_554/7}). +-compile({nowarn_unused_function, yeccpars2_554/7}). +yeccpars2_554(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_554_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_555/7}). +-compile({nowarn_unused_function, yeccpars2_555/7}). +yeccpars2_555(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_555_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_556/7}). +-compile({nowarn_unused_function, yeccpars2_556/7}). +yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_556_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_557/7}). +-compile({nowarn_unused_function, yeccpars2_557/7}). +yeccpars2_557(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_$end'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_)'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_,'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '.', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_.'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '.', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_;'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_>>'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_]'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_and_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_arrow_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_assoc_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_block_identifier(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_comp_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_concat_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_dot_call_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dot_call_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_dual_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_end(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_eol(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_in_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_in_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_mult_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_or_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_pipe_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_power_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_range_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_rel_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_stab_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_ternary_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_type_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_when_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_xor_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_}'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_557_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_558/7}). +-compile({nowarn_unused_function, yeccpars2_558/7}). +yeccpars2_558(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_558(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_559(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 568, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_560/7}). +-compile({nowarn_unused_function, yeccpars2_560/7}). +yeccpars2_560(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_560_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_561/7}). +-compile({nowarn_unused_function, yeccpars2_561/7}). +yeccpars2_561(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_561(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_561(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_561_(Stack), + yeccgoto_do_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_562/7}). +-compile({nowarn_unused_function, yeccpars2_562/7}). +yeccpars2_562(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_562_(Stack), + yeccgoto_do_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_563/7}). +-compile({nowarn_unused_function, yeccpars2_563/7}). +yeccpars2_563(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_563(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 574, Ss, Stack, T, Ts, Tzr); +yeccpars2_563(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_564/7}). +-compile({nowarn_unused_function, yeccpars2_564/7}). +yeccpars2_564(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 572, Ss, Stack, T, Ts, Tzr); +yeccpars2_564(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_565/7}). +-compile({nowarn_unused_function, yeccpars2_565/7}). +yeccpars2_565(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_565(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_565_(Stack), + yeccgoto_block_list(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_566/7}). +-compile({nowarn_unused_function, yeccpars2_566/7}). +yeccpars2_566(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_566_(Stack), + yeccgoto_block_item(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_567/7}). +-compile({nowarn_unused_function, yeccpars2_567/7}). +yeccpars2_567(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_567(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_567(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_567_(Stack), + yeccgoto_block_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_568/7}). +-compile({nowarn_unused_function, yeccpars2_568/7}). +yeccpars2_568(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_568_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_569/7}). +-compile({nowarn_unused_function, yeccpars2_569/7}). +yeccpars2_569(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_569_(Stack), + yeccgoto_block_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_570/7}). +-compile({nowarn_unused_function, yeccpars2_570/7}). +yeccpars2_570(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_570_(Stack), + yeccgoto_block_item(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_571/7}). +-compile({nowarn_unused_function, yeccpars2_571/7}). +yeccpars2_571(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_571_(Stack), + yeccgoto_block_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_572/7}). +-compile({nowarn_unused_function, yeccpars2_572/7}). +yeccpars2_572(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_572_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_573/7}). +-compile({nowarn_unused_function, yeccpars2_573/7}). +yeccpars2_573(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 575, Ss, Stack, T, Ts, Tzr); +yeccpars2_573(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_574/7}). +-compile({nowarn_unused_function, yeccpars2_574/7}). +yeccpars2_574(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_574_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_575/7}). +-compile({nowarn_unused_function, yeccpars2_575/7}). +yeccpars2_575(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_575_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_576/7}). +-compile({nowarn_unused_function, yeccpars2_576/7}). +yeccpars2_576(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_$end'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_)'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_,'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '.', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_.'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '.', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_;'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_>>'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_]'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_and_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_arrow_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_assoc_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_block_identifier(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_comp_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_concat_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_dot_call_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dot_call_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_dual_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_end(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_eol(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_in_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_in_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_mult_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_or_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_pipe_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_power_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_range_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_rel_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_stab_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_ternary_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_type_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_when_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_xor_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_}'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_576_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_577: see yeccpars2_558 + +-dialyzer({nowarn_function, yeccpars2_578/7}). +-compile({nowarn_unused_function, yeccpars2_578/7}). +yeccpars2_578(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_578_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_579/7}). +-compile({nowarn_unused_function, yeccpars2_579/7}). +yeccpars2_579(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_579_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_580(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_581/7}). +-compile({nowarn_unused_function, yeccpars2_581/7}). +yeccpars2_581(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_581_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_582/7}). +-compile({nowarn_unused_function, yeccpars2_582/7}). +yeccpars2_582(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_582_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_583/7}). +-compile({nowarn_unused_function, yeccpars2_583/7}). +yeccpars2_583(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_583_(Stack), + yeccgoto_assoc_update_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_584/7}). +-compile({nowarn_unused_function, yeccpars2_584/7}). +yeccpars2_584(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_584_(Stack), + yeccgoto_assoc_update(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_585(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_586/7}). +-compile({nowarn_unused_function, yeccpars2_586/7}). +yeccpars2_586(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_586_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_587/7}). +-compile({nowarn_unused_function, yeccpars2_587/7}). +yeccpars2_587(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_587_(Stack), + yeccgoto_assoc_update_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_588/7}). +-compile({nowarn_unused_function, yeccpars2_588/7}). +yeccpars2_588(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_588_(Stack), + yeccgoto_assoc_update(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_589/7}). +-compile({nowarn_unused_function, yeccpars2_589/7}). +yeccpars2_589(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_589_(Stack), + yeccgoto_bracket_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_590/7}). +-compile({nowarn_unused_function, yeccpars2_590/7}). +yeccpars2_590(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_590_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_591/7}). +-compile({nowarn_unused_function, yeccpars2_591/7}). +yeccpars2_591(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_591_(Stack), + yeccgoto_bracket_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_592/7}). +-compile({nowarn_unused_function, yeccpars2_592/7}). +yeccpars2_592(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_592(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_592(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_592_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_593/7}). +-compile({nowarn_unused_function, yeccpars2_593/7}). +yeccpars2_593(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_593_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_594/7}). +-compile({nowarn_unused_function, yeccpars2_594/7}). +yeccpars2_594(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_594(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_594_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_595/7}). +-compile({nowarn_unused_function, yeccpars2_595/7}). +yeccpars2_595(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_595_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_596/7}). +-compile({nowarn_unused_function, yeccpars2_596/7}). +yeccpars2_596(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_596_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_597/7}). +-compile({nowarn_unused_function, yeccpars2_597/7}). +yeccpars2_597(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_$end'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '$end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_)'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ',', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_,'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ',', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_;'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_>>'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '>>', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ']', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_]'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ']', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_and_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'and_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_arrow_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'arrow_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_assoc_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'assoc_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_block_identifier(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_comp_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'comp_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_concat_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'concat_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_dual_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'dual_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_end(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_eol(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_in_match_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'in_match_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_in_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'in_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_match_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'match_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_mult_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'mult_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_or_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'or_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_pipe_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'pipe_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_power_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'power_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_range_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'range_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_rel_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'rel_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_stab_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'stab_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_ternary_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'ternary_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_type_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'type_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_when_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'when_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_xor_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'xor_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, '}', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_}'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '}', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_598/7}). +-compile({nowarn_unused_function, yeccpars2_598/7}). +yeccpars2_598(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_$end'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_)'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_,'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_;'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_>>'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_]'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_and_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_arrow_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_assoc_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_block_identifier(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_comp_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_concat_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_dual_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_end(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_eol(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_in_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_in_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_mult_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_or_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_pipe_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_power_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_range_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_rel_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_stab_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_ternary_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_type_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_when_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_xor_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_}'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_598_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_599/7}). +-compile({nowarn_unused_function, yeccpars2_599/7}). +yeccpars2_599(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_$end'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_)'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_,'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_;'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_>>'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_]'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_and_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_arrow_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_assoc_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_block_identifier(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_comp_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_concat_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_dual_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_end(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_eol(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_in_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_in_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_mult_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_or_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_pipe_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_power_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_range_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_rel_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_stab_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_ternary_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_type_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_when_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_xor_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_}'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_599_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_600/7}). +-compile({nowarn_unused_function, yeccpars2_600/7}). +yeccpars2_600(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_600(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_600(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_600_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_601/7}). +-compile({nowarn_unused_function, yeccpars2_601/7}). +yeccpars2_601(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_601_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_602/7}). +-compile({nowarn_unused_function, yeccpars2_602/7}). +yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_602_(Stack), + yeccgoto_expr_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_603/7}). +-compile({nowarn_unused_function, yeccpars2_603/7}). +yeccpars2_603(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_603_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_604/7}). +-compile({nowarn_unused_function, yeccpars2_604/7}). +yeccpars2_604(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 605, Ss, Stack, T, Ts, Tzr); +yeccpars2_604(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_605/7}). +-compile({nowarn_unused_function, yeccpars2_605/7}). +yeccpars2_605(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_605_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_606/7}). +-compile({nowarn_unused_function, yeccpars2_606/7}). +yeccpars2_606(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_606_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_607/7}). +-compile({nowarn_unused_function, yeccpars2_607/7}). +yeccpars2_607(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 614, Ss, Stack, T, Ts, Tzr); +yeccpars2_607(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_608/7}). +-compile({nowarn_unused_function, yeccpars2_608/7}). +yeccpars2_608(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 611, Ss, Stack, T, Ts, Tzr); +yeccpars2_608(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 612, Ss, Stack, T, Ts, Tzr); +yeccpars2_608(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_609/7}). +-compile({nowarn_unused_function, yeccpars2_609/7}). +yeccpars2_609(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_609_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_610/7}). +-compile({nowarn_unused_function, yeccpars2_610/7}). +yeccpars2_610(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_610_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_611/7}). +-compile({nowarn_unused_function, yeccpars2_611/7}). +yeccpars2_611(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_611_(Stack), + yeccgoto_close_bit(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_612/7}). +-compile({nowarn_unused_function, yeccpars2_612/7}). +yeccpars2_612(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 613, Ss, Stack, T, Ts, Tzr); +yeccpars2_612(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_613/7}). +-compile({nowarn_unused_function, yeccpars2_613/7}). +yeccpars2_613(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_613_(Stack), + yeccgoto_close_bit(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_614/7}). +-compile({nowarn_unused_function, yeccpars2_614/7}). +yeccpars2_614(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_614_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_615: see yeccpars2_245 + +-dialyzer({nowarn_function, yeccpars2_616/7}). +-compile({nowarn_unused_function, yeccpars2_616/7}). +yeccpars2_616(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_616_(Stack), + yeccgoto_list_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_617/7}). +-compile({nowarn_unused_function, yeccpars2_617/7}). +yeccpars2_617(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 619, Ss, Stack, T, Ts, Tzr); +yeccpars2_617(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_617_(Stack), + yeccgoto_list_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_618/7}). +-compile({nowarn_unused_function, yeccpars2_618/7}). +yeccpars2_618(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_618_(Stack), + yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_619/7}). +-compile({nowarn_unused_function, yeccpars2_619/7}). +yeccpars2_619(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_619_(Stack), + yeccgoto_list_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_620/7}). +-compile({nowarn_unused_function, yeccpars2_620/7}). +yeccpars2_620(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_620_(Stack), + yeccgoto_list_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_621/7}). +-compile({nowarn_unused_function, yeccpars2_621/7}). +yeccpars2_621(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_621_(Stack), + yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_622/7}). +-compile({nowarn_unused_function, yeccpars2_622/7}). +yeccpars2_622(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 626, Ss, Stack, T, Ts, Tzr); +yeccpars2_622(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_623: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_624/7}). +-compile({nowarn_unused_function, yeccpars2_624/7}). +yeccpars2_624(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_624_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_625/7}). +-compile({nowarn_unused_function, yeccpars2_625/7}). +yeccpars2_625(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_625_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_626/7}). +-compile({nowarn_unused_function, yeccpars2_626/7}). +yeccpars2_626(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_626_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_access_expr/7}). +-compile({nowarn_unused_function, yeccgoto_access_expr/7}). +yeccgoto_access_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_and_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_and_op_eol/7}). +yeccgoto_and_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_arrow_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_arrow_op_eol/7}). +yeccgoto_arrow_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc/7}). +-compile({nowarn_unused_function, yeccgoto_assoc/7}). +yeccgoto_assoc(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(483, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(483, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_base/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_base/7}). +yeccgoto_assoc_base(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_482(482, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_base(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_482(482, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_expr/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_expr/7}). +yeccgoto_assoc_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_501(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_584(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_588(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_op_eol/7}). +yeccgoto_assoc_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_update/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_update/7}). +yeccgoto_assoc_update(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_480(480, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_update_kw/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_update_kw/7}). +yeccgoto_assoc_update_kw(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(479, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_at_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_at_op_eol/7}). +yeccgoto_at_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bitstring/7}). +-compile({nowarn_unused_function, yeccgoto_bitstring/7}). +yeccgoto_bitstring(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_block_eoe/7}). +yeccgoto_block_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_eoe(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_eoe(565, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_expr/7}). +-compile({nowarn_unused_function, yeccgoto_block_expr/7}). +yeccgoto_block_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_item/7}). +-compile({nowarn_unused_function, yeccgoto_block_item/7}). +yeccgoto_block_item(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_item(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_item(565, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_list/7}). +-compile({nowarn_unused_function, yeccgoto_block_list/7}). +yeccgoto_block_list(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_564(564, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_list(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_573(573, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_list(565=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_571(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_arg/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_arg/7}). +yeccgoto_bracket_arg(30=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_591(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(38=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_589(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(240=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_256(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(241=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_at_expr/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_at_expr/7}). +yeccgoto_bracket_at_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_expr/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_expr/7}). +yeccgoto_bracket_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_all/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_all/7}). +yeccgoto_call_args_no_parens_all(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(577, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(558, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(577, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(558, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_ambig/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_ambig/7}). +yeccgoto_call_args_no_parens_ambig(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_599(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_598(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_415(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_comma_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_comma_expr/7}). +yeccgoto_call_args_no_parens_comma_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_expr/7}). +yeccgoto_call_args_no_parens_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_366(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_369(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_kw/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_kw/7}). +yeccgoto_call_args_no_parens_kw(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_383(383, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_365(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_368(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_402(402, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_kw_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_kw_expr/7}). +yeccgoto_call_args_no_parens_kw_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_many/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_many/7}). +yeccgoto_call_args_no_parens_many(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_382(382, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_401(401, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_many_strict/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_many_strict/7}). +yeccgoto_call_args_no_parens_many_strict(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_one/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_one/7}). +yeccgoto_call_args_no_parens_one(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens/7}). +yeccgoto_call_args_parens(29, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_592(592, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(198, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_259(259, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(259=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_594(594, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens_base/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens_base/7}). +yeccgoto_call_args_parens_base(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_267(267, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens_expr/7}). +yeccgoto_call_args_parens_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_266(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_276(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_capture_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_capture_op_eol/7}). +yeccgoto_capture_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_bit/7}). +-compile({nowarn_unused_function, yeccgoto_close_bit/7}). +yeccgoto_close_bit(608=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_610(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_bracket/7}). +-compile({nowarn_unused_function, yeccgoto_close_bracket/7}). +yeccgoto_close_bracket(245=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_255(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(246=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_253(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(252=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(615=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_621(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_curly/7}). +-compile({nowarn_unused_function, yeccgoto_close_curly/7}). +yeccgoto_close_curly(174=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(474=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_579(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(479=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_554(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(480=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_550(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(483=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_496(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(500=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_502(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_553(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(623=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_625(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_paren/7}). +-compile({nowarn_unused_function, yeccgoto_close_paren/7}). +yeccgoto_close_paren(262=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(264=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_280(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(267=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(275=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(382=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(383=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_395(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_391(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(401=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(402=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_403(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_comp_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_comp_op_eol/7}). +yeccgoto_comp_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_concat_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_concat_op_eol/7}). +yeccgoto_concat_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_args/7}). +-compile({nowarn_unused_function, yeccgoto_container_args/7}). +yeccgoto_container_args(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(623, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_608(608, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(252, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_args_base/7}). +-compile({nowarn_unused_function, yeccgoto_container_args_base/7}). +yeccgoto_container_args_base(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_617(617, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_expr/7}). +-compile({nowarn_unused_function, yeccgoto_container_expr/7}). +yeccgoto_container_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_246(246, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_do_block/7}). +-compile({nowarn_unused_function, yeccgoto_do_block/7}). +yeccgoto_do_block(28=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_596(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(558=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_560(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(577=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_578(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(592=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_593(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(594=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_595(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_do_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_do_eoe/7}). +yeccgoto_do_eoe(28, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(558, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(577, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(594, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_alias/7}). +-compile({nowarn_unused_function, yeccgoto_dot_alias/7}). +yeccgoto_dot_alias(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_bracket_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_bracket_identifier/7}). +yeccgoto_dot_bracket_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_call_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_call_identifier/7}). +yeccgoto_dot_call_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_do_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_do_identifier/7}). +yeccgoto_dot_do_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_identifier/7}). +yeccgoto_dot_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_op/7}). +-compile({nowarn_unused_function, yeccgoto_dot_op/7}). +yeccgoto_dot_op(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_op_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_op_identifier/7}). +yeccgoto_dot_op_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_paren_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_paren_identifier/7}). +yeccgoto_dot_paren_identifier(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dual_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_dual_op_eol/7}). +yeccgoto_dual_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_empty_paren/7}). +-compile({nowarn_unused_function, yeccgoto_empty_paren/7}). +yeccgoto_empty_paren(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_eoe/7}). +yeccgoto_eoe(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_23(23, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(21, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_603(603, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(63=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_80(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(375, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_405(405, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(561=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_562(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(567=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_569(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(600, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_601(601, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_expr/7}). +-compile({nowarn_unused_function, yeccgoto_expr/7}). +yeccgoto_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(399, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(411, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_expr_list/7}). +-compile({nowarn_unused_function, yeccgoto_expr_list/7}). +yeccgoto_expr_list(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_21(21, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr_list(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_600(600, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_fn_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_fn_eoe/7}). +yeccgoto_fn_eoe(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_grammar/7}). +-compile({nowarn_unused_function, yeccgoto_grammar/7}). +yeccgoto_grammar(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_19(19, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_in_match_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_in_match_op_eol/7}). +yeccgoto_in_match_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_in_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_in_op_eol/7}). +yeccgoto_in_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_base/7}). +-compile({nowarn_unused_function, yeccgoto_kw_base/7}). +yeccgoto_kw_base(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_call/7}). +-compile({nowarn_unused_function, yeccgoto_kw_call/7}). +yeccgoto_kw_call(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_call(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(275, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_data/7}). +-compile({nowarn_unused_function, yeccgoto_kw_data/7}). +yeccgoto_kw_data(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_622(622, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_616(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_607(607, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_182(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(245, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(474, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(500, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(474, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_583(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_587(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_620(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_eol/7}). +-compile({nowarn_unused_function, yeccgoto_kw_eol/7}). +yeccgoto_kw_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(194, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(194, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_list/7}). +-compile({nowarn_unused_function, yeccgoto_list/7}). +yeccgoto_list(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_list_args/7}). +-compile({nowarn_unused_function, yeccgoto_list_args/7}). +yeccgoto_list_args(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(615, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map/7}). +-compile({nowarn_unused_function, yeccgoto_map/7}). +yeccgoto_map(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_args/7}). +-compile({nowarn_unused_function, yeccgoto_map_args/7}). +yeccgoto_map_args(16=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_606(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_args(460=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_466(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_args(467=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_468(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_base_expr/7}). +-compile({nowarn_unused_function, yeccgoto_map_base_expr/7}). +yeccgoto_map_base_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_460(460, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_close/7}). +-compile({nowarn_unused_function, yeccgoto_map_close/7}). +yeccgoto_map_close(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_472(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_close(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_552(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_op/7}). +-compile({nowarn_unused_function, yeccgoto_map_op/7}). +yeccgoto_map_op(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_match_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_match_op_eol/7}). +yeccgoto_match_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_matched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_matched_expr/7}). +yeccgoto_matched_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_555(555, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_459(459, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_448(448, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_446(446, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_444(444, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_442(442, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_440(440, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_438(438, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_436(436, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_434(434, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_432(432, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_430(430, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_428(428, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_426(426, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_424(424, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_422(422, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_193(193, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_419(419, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_257(257, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_202(202, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_238(238, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_237(237, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_236(236, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_235(235, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_234(234, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_233(233, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_232(232, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_231(231, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_230(230, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_229(229, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_228(228, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_225(225, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_224(224, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_223(223, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_222(222, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_221(221, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_279(279, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_292(292, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_288(288, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_417(417, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_354(354, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_352(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_299(299, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_350(350, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_347(347, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_345(345, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_343(343, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_341(341, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_339(339, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_337(337, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_335(335, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_333(333, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_331(331, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_329(329, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_327(327, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_325(325, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_323(323, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_321(321, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_320(320, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_318(318, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_364(364, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_364(364, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_419(419, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_202(202, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(471, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_555(555, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(499, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_546(546, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_545(545, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_544(544, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_543(543, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_542(542, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_541(541, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_540(540, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_539(539, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_538(538, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_537(537, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_536(536, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_535(535, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_534(534, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_533(533, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_532(532, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_531(531, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_530(530, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_528(528, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_525(525, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_549(549, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(499, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_582(582, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_586(586, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_matched_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_matched_op_expr/7}). +yeccgoto_matched_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(193=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(202=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(223=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(225=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(226=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(227=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(228=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(230=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(232=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(234=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(236=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(237=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(238=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(257=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(279=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(288=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(292=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(299=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(318=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(319=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(320=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(321=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(323=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(325=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(333=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(335=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(337=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(341=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(345=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(350=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(354=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(357=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(417=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(419=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(459=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(471=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(499=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(525=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(528=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(530=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(531=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(532=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(533=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(534=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(535=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(536=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(537=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(538=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(539=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(540=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(541=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(542=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(543=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(544=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(545=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(546=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(549=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(582=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_mult_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_mult_op_eol/7}). +yeccgoto_mult_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_expr/7}). +yeccgoto_no_parens_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_590(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_262(262, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_274(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_416(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_353(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_351(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_many_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_many_expr/7}). +yeccgoto_no_parens_many_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_one_ambig_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_one_ambig_expr/7}). +yeccgoto_no_parens_one_ambig_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_one_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_one_expr/7}). +yeccgoto_no_parens_one_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_op_expr/7}). +yeccgoto_no_parens_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(292=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(299=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(318=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(319=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(320=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(321=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(323=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(325=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(333=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(335=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(337=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(341=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(345=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(350=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(354=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(357=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(417=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_zero_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_zero_expr/7}). +yeccgoto_no_parens_zero_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_bit/7}). +-compile({nowarn_unused_function, yeccgoto_open_bit/7}). +yeccgoto_open_bit(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_bracket/7}). +-compile({nowarn_unused_function, yeccgoto_open_bracket/7}). +yeccgoto_open_bracket(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(30, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(38, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(240, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(241, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_curly/7}). +-compile({nowarn_unused_function, yeccgoto_open_curly/7}). +yeccgoto_open_curly(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(16, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(102, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(460, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(467, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_paren/7}). +-compile({nowarn_unused_function, yeccgoto_open_paren/7}). +yeccgoto_open_paren(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(29, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(198, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(259, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_or_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_or_op_eol/7}). +yeccgoto_or_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_parens_call/7}). +-compile({nowarn_unused_function, yeccgoto_parens_call/7}). +yeccgoto_parens_call(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_pipe_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_pipe_op_eol/7}). +yeccgoto_pipe_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_585(585, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_580(580, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_power_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_power_op_eol/7}). +yeccgoto_power_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_range_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_range_op_eol/7}). +yeccgoto_range_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_rel_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_rel_op_eol/7}). +yeccgoto_rel_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab/7}). +-compile({nowarn_unused_function, yeccgoto_stab/7}). +yeccgoto_stab(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_stab_eoe/7}). +yeccgoto_stab_eoe(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_604(604, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_390(390, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_563(563, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_570(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_expr/7}). +-compile({nowarn_unused_function, yeccgoto_stab_expr/7}). +yeccgoto_stab_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_stab_op_eol/7}). +yeccgoto_stab_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(370, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(380, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(385, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(399, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(411, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_op_eol_and_expr/7}). +-compile({nowarn_unused_function, yeccgoto_stab_op_eol_and_expr/7}). +yeccgoto_stab_op_eol_and_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(370=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(380=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_397(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(399=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(411=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_parens_many/7}). +-compile({nowarn_unused_function, yeccgoto_stab_parens_many/7}). +yeccgoto_stab_parens_many(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_sub_matched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_sub_matched_expr/7}). +yeccgoto_sub_matched_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_ternary_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_ternary_op_eol/7}). +yeccgoto_ternary_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_tuple/7}). +-compile({nowarn_unused_function, yeccgoto_tuple/7}). +yeccgoto_tuple(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_type_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_type_op_eol/7}). +yeccgoto_type_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unary_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_unary_op_eol/7}). +yeccgoto_unary_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unmatched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_unmatched_expr/7}). +yeccgoto_unmatched_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_447(447, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_445(445, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_443(443, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_441(441, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_439(439, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_437(437, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_433(433, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_431(431, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_429(429, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_427(427, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_425(425, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_423(423, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_421(421, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_152(152, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_261(261, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_261(261, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(469, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(498, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_447(447, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_445(445, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_443(443, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_441(441, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_439(439, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_437(437, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_433(433, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_431(431, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_429(429, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_427(427, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_425(425, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_423(423, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_421(421, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_529(529, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_152(152, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_548(548, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(498, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_581(581, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_581(581, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unmatched_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_unmatched_op_expr/7}). +yeccgoto_unmatched_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(471=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(499=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(525=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(528=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(530=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(531=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(532=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(533=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(534=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(535=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(536=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(537=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(538=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(539=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(540=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(541=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(542=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(543=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(544=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(545=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(546=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(549=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(582=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_when_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_when_op_eol/7}). +yeccgoto_when_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_xor_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_xor_op_eol/7}). +yeccgoto_xor_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr). + +-compile({inline,yeccpars2_0_/1}). +-dialyzer({nowarn_function, yeccpars2_0_/1}). +-compile({nowarn_unused_function, yeccpars2_0_/1}). +-file("src/future_elixir_parser.yrl", 93). +yeccpars2_0_(__Stack0) -> + [begin + {'__block__', [], []} + end | __Stack0]. + +-compile({inline,yeccpars2_1_/1}). +-dialyzer({nowarn_function, yeccpars2_1_/1}). +-compile({nowarn_unused_function, yeccpars2_1_/1}). +-file("src/future_elixir_parser.yrl", 101). +yeccpars2_1_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_3_/1}). +-dialyzer({nowarn_function, yeccpars2_3_/1}). +-compile({nowarn_unused_function, yeccpars2_3_/1}). +-file("src/future_elixir_parser.yrl", 273). +yeccpars2_3_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_4_/1}). +-dialyzer({nowarn_function, yeccpars2_4_/1}). +-compile({nowarn_unused_function, yeccpars2_4_/1}). +-file("src/future_elixir_parser.yrl", 148). +yeccpars2_4_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_5_/1}). +-dialyzer({nowarn_function, yeccpars2_5_/1}). +-compile({nowarn_unused_function, yeccpars2_5_/1}). +-file("src/future_elixir_parser.yrl", 288). +yeccpars2_5_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_10_/1}). +-dialyzer({nowarn_function, yeccpars2_10_/1}). +-compile({nowarn_unused_function, yeccpars2_10_/1}). +-file("src/future_elixir_parser.yrl", 250). +yeccpars2_10_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_11_/1}). +-dialyzer({nowarn_function, yeccpars2_11_/1}). +-compile({nowarn_unused_function, yeccpars2_11_/1}). +-file("src/future_elixir_parser.yrl", 147). +yeccpars2_11_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_12_/1}). +-dialyzer({nowarn_function, yeccpars2_12_/1}). +-compile({nowarn_unused_function, yeccpars2_12_/1}). +-file("src/future_elixir_parser.yrl", 165). +yeccpars2_12_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_13_/1}). +-dialyzer({nowarn_function, yeccpars2_13_/1}). +-compile({nowarn_unused_function, yeccpars2_13_/1}). +-file("src/future_elixir_parser.yrl", 166). +yeccpars2_13_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_14_/1}). +-dialyzer({nowarn_function, yeccpars2_14_/1}). +-compile({nowarn_unused_function, yeccpars2_14_/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_14_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_15_/1}). +-dialyzer({nowarn_function, yeccpars2_15_/1}). +-compile({nowarn_unused_function, yeccpars2_15_/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_15_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_17_/1}). +-dialyzer({nowarn_function, yeccpars2_17_/1}). +-compile({nowarn_unused_function, yeccpars2_17_/1}). +-file("src/future_elixir_parser.yrl", 272). +yeccpars2_17_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_18_/1}). +-dialyzer({nowarn_function, yeccpars2_18_/1}). +-compile({nowarn_unused_function, yeccpars2_18_/1}). +-file("src/future_elixir_parser.yrl", 271). +yeccpars2_18_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + element(1, ___1) + end | __Stack]. + +-compile({inline,yeccpars2_21_/1}). +-dialyzer({nowarn_function, yeccpars2_21_/1}). +-compile({nowarn_unused_function, yeccpars2_21_/1}). +-file("src/future_elixir_parser.yrl", 89). +yeccpars2_21_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_block(reverse(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_22_/1}). +-dialyzer({nowarn_function, yeccpars2_22_/1}). +-compile({nowarn_unused_function, yeccpars2_22_/1}). +-file("src/future_elixir_parser.yrl", 96). +yeccpars2_22_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_23_/1}). +-dialyzer({nowarn_function, yeccpars2_23_/1}). +-compile({nowarn_unused_function, yeccpars2_23_/1}). +-file("src/future_elixir_parser.yrl", 88). +yeccpars2_23_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + {'__block__', meta_from_token(___1), []} + end | __Stack]. + +-compile({inline,yeccpars2_24_/1}). +-dialyzer({nowarn_function, yeccpars2_24_/1}). +-compile({nowarn_unused_function, yeccpars2_24_/1}). +-file("src/future_elixir_parser.yrl", 267). +yeccpars2_24_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_paren(___1), {'__block__', [], []} + end | __Stack]. + +-compile({inline,yeccpars2_25_/1}). +-dialyzer({nowarn_function, yeccpars2_25_/1}). +-compile({nowarn_unused_function, yeccpars2_25_/1}). +-file("src/future_elixir_parser.yrl", 484). +yeccpars2_25_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_27_/1}). +-dialyzer({nowarn_function, yeccpars2_27_/1}). +-compile({nowarn_unused_function, yeccpars2_27_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_27_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_28_/1}). +-dialyzer({nowarn_function, yeccpars2_28_/1}). +-compile({nowarn_unused_function, yeccpars2_28_/1}). +-file("src/future_elixir_parser.yrl", 247). +yeccpars2_28_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_31_/1}). +-dialyzer({nowarn_function, yeccpars2_31_/1}). +-compile({nowarn_unused_function, yeccpars2_31_/1}). +-file("src/future_elixir_parser.yrl", 287). +yeccpars2_31_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_33_/1}). +-dialyzer({nowarn_function, yeccpars2_33_/1}). +-compile({nowarn_unused_function, yeccpars2_33_/1}). +-file("src/future_elixir_parser.yrl", 261). +yeccpars2_33_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_34_/1}). +-dialyzer({nowarn_function, yeccpars2_34_/1}). +-compile({nowarn_unused_function, yeccpars2_34_/1}). +-file("src/future_elixir_parser.yrl", 260). +yeccpars2_34_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_35_/1}). +-dialyzer({nowarn_function, yeccpars2_35_/1}). +-compile({nowarn_unused_function, yeccpars2_35_/1}). +-file("src/future_elixir_parser.yrl", 158). +yeccpars2_35_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_36_/1}). +-dialyzer({nowarn_function, yeccpars2_36_/1}). +-compile({nowarn_unused_function, yeccpars2_36_/1}). +-file("src/future_elixir_parser.yrl", 281). +yeccpars2_36_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_38_/1}). +-dialyzer({nowarn_function, yeccpars2_38_/1}). +-compile({nowarn_unused_function, yeccpars2_38_/1}). +-file("src/future_elixir_parser.yrl", 253). +yeccpars2_38_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_40_/1}). +-dialyzer({nowarn_function, yeccpars2_40_/1}). +-compile({nowarn_unused_function, yeccpars2_40_/1}). +-file("src/future_elixir_parser.yrl", 628). +yeccpars2_40_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_41_/1}). +-dialyzer({nowarn_function, yeccpars2_41_/1}). +-compile({nowarn_unused_function, yeccpars2_41_/1}). +-file("src/future_elixir_parser.yrl", 365). +yeccpars2_41_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_42_/1}). +-dialyzer({nowarn_function, yeccpars2_42_/1}). +-compile({nowarn_unused_function, yeccpars2_42_/1}). +-file("src/future_elixir_parser.yrl", 319). +yeccpars2_42_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_43_/1}). +-dialyzer({nowarn_function, yeccpars2_43_/1}). +-compile({nowarn_unused_function, yeccpars2_43_/1}). +-file("src/future_elixir_parser.yrl", 377). +yeccpars2_43_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_44_/1}). +-dialyzer({nowarn_function, yeccpars2_44_/1}). +-compile({nowarn_unused_function, yeccpars2_44_/1}). +-file("src/future_elixir_parser.yrl", 372). +yeccpars2_44_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_45_/1}). +-dialyzer({nowarn_function, yeccpars2_45_/1}). +-compile({nowarn_unused_function, yeccpars2_45_/1}). +-file("src/future_elixir_parser.yrl", 467). +yeccpars2_45_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_alias(___1) + end | __Stack]. + +-compile({inline,yeccpars2_46_/1}). +-dialyzer({nowarn_function, yeccpars2_46_/1}). +-compile({nowarn_unused_function, yeccpars2_46_/1}). +-file("src/future_elixir_parser.yrl", 399). +yeccpars2_46_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27643). +-compile({inline,yeccpars2_47_/1}). +-dialyzer({nowarn_function, yeccpars2_47_/1}). +-compile({nowarn_unused_function, yeccpars2_47_/1}). +-file("src/future_elixir_parser.yrl", 283). +yeccpars2_47_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27654). +-compile({inline,yeccpars2_48_/1}). +-dialyzer({nowarn_function, yeccpars2_48_/1}). +-compile({nowarn_unused_function, yeccpars2_48_/1}). +-file("src/future_elixir_parser.yrl", 284). +yeccpars2_48_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_49_/1}). +-dialyzer({nowarn_function, yeccpars2_49_/1}). +-compile({nowarn_unused_function, yeccpars2_49_/1}). +-file("src/future_elixir_parser.yrl", 285). +yeccpars2_49_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_50_/1}). +-dialyzer({nowarn_function, yeccpars2_50_/1}). +-compile({nowarn_unused_function, yeccpars2_50_/1}). +-file("src/future_elixir_parser.yrl", 286). +yeccpars2_50_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_51_/1}). +-dialyzer({nowarn_function, yeccpars2_51_/1}). +-compile({nowarn_unused_function, yeccpars2_51_/1}). +-file("src/future_elixir_parser.yrl", 279). +yeccpars2_51_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_bin_heredoc(___1) + end | __Stack]. + +-compile({inline,yeccpars2_52_/1}). +-dialyzer({nowarn_function, yeccpars2_52_/1}). +-compile({nowarn_unused_function, yeccpars2_52_/1}). +-file("src/future_elixir_parser.yrl", 277). +yeccpars2_52_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_bin_string(___1, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_53_/1}). +-dialyzer({nowarn_function, yeccpars2_53_/1}). +-compile({nowarn_unused_function, yeccpars2_53_/1}). +-file("src/future_elixir_parser.yrl", 478). +yeccpars2_53_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_55_/1}). +-dialyzer({nowarn_function, yeccpars2_55_/1}). +-compile({nowarn_unused_function, yeccpars2_55_/1}). +-file("src/future_elixir_parser.yrl", 396). +yeccpars2_55_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27725). +-compile({inline,yeccpars2_56_/1}). +-dialyzer({nowarn_function, yeccpars2_56_/1}). +-compile({nowarn_unused_function, yeccpars2_56_/1}). +-file("src/future_elixir_parser.yrl", 270). +yeccpars2_56_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(?exprs(___1), ___1, number_value(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_57_/1}). +-dialyzer({nowarn_function, yeccpars2_57_/1}). +-compile({nowarn_unused_function, yeccpars2_57_/1}). +-file("src/future_elixir_parser.yrl", 475). +yeccpars2_57_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_58_/1}). +-dialyzer({nowarn_function, yeccpars2_58_/1}). +-compile({nowarn_unused_function, yeccpars2_58_/1}). +-file("src/future_elixir_parser.yrl", 391). +yeccpars2_58_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_59_/1}). +-dialyzer({nowarn_function, yeccpars2_59_/1}). +-compile({nowarn_unused_function, yeccpars2_59_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_59_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_60_/1}). +-dialyzer({nowarn_function, yeccpars2_60_/1}). +-compile({nowarn_unused_function, yeccpars2_60_/1}). +-file("src/future_elixir_parser.yrl", 318). +yeccpars2_60_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27776). +-compile({inline,yeccpars2_61_/1}). +-dialyzer({nowarn_function, yeccpars2_61_/1}). +-compile({nowarn_unused_function, yeccpars2_61_/1}). +-file("src/future_elixir_parser.yrl", 275). +yeccpars2_61_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27787). +-compile({inline,yeccpars2_62_/1}). +-dialyzer({nowarn_function, yeccpars2_62_/1}). +-compile({nowarn_unused_function, yeccpars2_62_/1}). +-file("src/future_elixir_parser.yrl", 269). +yeccpars2_62_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(number_value(___1), ___1, ?exprs(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_63_/1}). +-dialyzer({nowarn_function, yeccpars2_63_/1}). +-compile({nowarn_unused_function, yeccpars2_63_/1}). +-file("src/future_elixir_parser.yrl", 322). +yeccpars2_63_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_64_/1}). +-dialyzer({nowarn_function, yeccpars2_64_/1}). +-compile({nowarn_unused_function, yeccpars2_64_/1}). +-file("src/future_elixir_parser.yrl", 464). +yeccpars2_64_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27818). +-compile({inline,yeccpars2_65_/1}). +-dialyzer({nowarn_function, yeccpars2_65_/1}). +-compile({nowarn_unused_function, yeccpars2_65_/1}). +-file("src/future_elixir_parser.yrl", 268). +yeccpars2_65_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(number_value(___1), ___1, ?exprs(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_66_/1}). +-dialyzer({nowarn_function, yeccpars2_66_/1}). +-compile({nowarn_unused_function, yeccpars2_66_/1}). +-file("src/future_elixir_parser.yrl", 280). +yeccpars2_66_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_list_heredoc(___1) + end | __Stack]. + +-compile({inline,yeccpars2_67_/1}). +-dialyzer({nowarn_function, yeccpars2_67_/1}). +-compile({nowarn_unused_function, yeccpars2_67_/1}). +-file("src/future_elixir_parser.yrl", 278). +yeccpars2_67_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_list_string(___1, delimiter(<<$'>>)) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27849). +-compile({inline,yeccpars2_68_/1}). +-dialyzer({nowarn_function, yeccpars2_68_/1}). +-compile({nowarn_unused_function, yeccpars2_68_/1}). +-file("src/future_elixir_parser.yrl", 276). +yeccpars2_68_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-compile({inline,yeccpars2_69_/1}). +-dialyzer({nowarn_function, yeccpars2_69_/1}). +-compile({nowarn_unused_function, yeccpars2_69_/1}). +-file("src/future_elixir_parser.yrl", 472). +yeccpars2_69_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_70_/1}). +-dialyzer({nowarn_function, yeccpars2_70_/1}). +-compile({nowarn_unused_function, yeccpars2_70_/1}). +-file("src/future_elixir_parser.yrl", 481). +yeccpars2_70_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_71_/1}). +-dialyzer({nowarn_function, yeccpars2_71_/1}). +-compile({nowarn_unused_function, yeccpars2_71_/1}). +-file("src/future_elixir_parser.yrl", 251). +yeccpars2_71_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_72_/1}). +-dialyzer({nowarn_function, yeccpars2_72_/1}). +-compile({nowarn_unused_function, yeccpars2_72_/1}). +-file("src/future_elixir_parser.yrl", 282). +yeccpars2_72_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_sigil(___1) + end | __Stack]. + +-compile({inline,yeccpars2_73_/1}). +-dialyzer({nowarn_function, yeccpars2_73_/1}). +-compile({nowarn_unused_function, yeccpars2_73_/1}). +-file("src/future_elixir_parser.yrl", 393). +yeccpars2_73_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27910). +-compile({inline,yeccpars2_74_/1}). +-dialyzer({nowarn_function, yeccpars2_74_/1}). +-compile({nowarn_unused_function, yeccpars2_74_/1}). +-file("src/future_elixir_parser.yrl", 274). +yeccpars2_74_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-compile({inline,yeccpars2_75_/1}). +-dialyzer({nowarn_function, yeccpars2_75_/1}). +-compile({nowarn_unused_function, yeccpars2_75_/1}). +-file("src/future_elixir_parser.yrl", 389). +yeccpars2_75_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_76_/1}). +-dialyzer({nowarn_function, yeccpars2_76_/1}). +-compile({nowarn_unused_function, yeccpars2_76_/1}). +-file("src/future_elixir_parser.yrl", 382). +yeccpars2_76_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_77_/1}). +-dialyzer({nowarn_function, yeccpars2_77_/1}). +-compile({nowarn_unused_function, yeccpars2_77_/1}). +-file("src/future_elixir_parser.yrl", 383). +yeccpars2_77_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_78_/1}). +-dialyzer({nowarn_function, yeccpars2_78_/1}). +-compile({nowarn_unused_function, yeccpars2_78_/1}). +-file("src/future_elixir_parser.yrl", 390). +yeccpars2_78_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_79_/1}). +-dialyzer({nowarn_function, yeccpars2_79_/1}). +-compile({nowarn_unused_function, yeccpars2_79_/1}). +-file("src/future_elixir_parser.yrl", 394). +yeccpars2_79_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_80_/1}). +-dialyzer({nowarn_function, yeccpars2_80_/1}). +-compile({nowarn_unused_function, yeccpars2_80_/1}). +-file("src/future_elixir_parser.yrl", 323). +yeccpars2_80_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_81_/1}). +-dialyzer({nowarn_function, yeccpars2_81_/1}). +-compile({nowarn_unused_function, yeccpars2_81_/1}). +-file("src/future_elixir_parser.yrl", 320). +yeccpars2_81_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_82_/1}). +-dialyzer({nowarn_function, yeccpars2_82_/1}). +-compile({nowarn_unused_function, yeccpars2_82_/1}). +-file("src/future_elixir_parser.yrl", 164). +yeccpars2_82_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_83_/1}). +-dialyzer({nowarn_function, yeccpars2_83_/1}). +-compile({nowarn_unused_function, yeccpars2_83_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_83_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_84_/1}). +-dialyzer({nowarn_function, yeccpars2_84_/1}). +-compile({nowarn_unused_function, yeccpars2_84_/1}). +-file("src/future_elixir_parser.yrl", 157). +yeccpars2_84_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_87_/1}). +-dialyzer({nowarn_function, yeccpars2_87_/1}). +-compile({nowarn_unused_function, yeccpars2_87_/1}). +-file("src/future_elixir_parser.yrl", 150). +yeccpars2_87_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_95_/1}). +-dialyzer({nowarn_function, yeccpars2_95_/1}). +-compile({nowarn_unused_function, yeccpars2_95_/1}). +-file("src/future_elixir_parser.yrl", 160). +yeccpars2_95_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_97_/1}). +-dialyzer({nowarn_function, yeccpars2_97_/1}). +-compile({nowarn_unused_function, yeccpars2_97_/1}). +-file("src/future_elixir_parser.yrl", 142). +yeccpars2_97_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_107_/1}). +-dialyzer({nowarn_function, yeccpars2_107_/1}). +-compile({nowarn_unused_function, yeccpars2_107_/1}). +-file("src/future_elixir_parser.yrl", 461). +yeccpars2_107_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_108_/1}). +-dialyzer({nowarn_function, yeccpars2_108_/1}). +-compile({nowarn_unused_function, yeccpars2_108_/1}). +-file("src/future_elixir_parser.yrl", 429). +yeccpars2_108_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_109_/1}). +-dialyzer({nowarn_function, yeccpars2_109_/1}). +-compile({nowarn_unused_function, yeccpars2_109_/1}). +-file("src/future_elixir_parser.yrl", 456). +yeccpars2_109_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_110_/1}). +-dialyzer({nowarn_function, yeccpars2_110_/1}). +-compile({nowarn_unused_function, yeccpars2_110_/1}). +-file("src/future_elixir_parser.yrl", 450). +yeccpars2_110_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_111_/1}). +-dialyzer({nowarn_function, yeccpars2_111_/1}). +-compile({nowarn_unused_function, yeccpars2_111_/1}). +-file("src/future_elixir_parser.yrl", 414). +yeccpars2_111_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_112_/1}). +-dialyzer({nowarn_function, yeccpars2_112_/1}). +-compile({nowarn_unused_function, yeccpars2_112_/1}). +-file("src/future_elixir_parser.yrl", 485). +yeccpars2_112_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {'.', meta_from_token(___2), [___1]} + end | __Stack]. + +-compile({inline,yeccpars2_113_/1}). +-dialyzer({nowarn_function, yeccpars2_113_/1}). +-compile({nowarn_unused_function, yeccpars2_113_/1}). +-file("src/future_elixir_parser.yrl", 405). +yeccpars2_113_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_114_/1}). +-dialyzer({nowarn_function, yeccpars2_114_/1}). +-compile({nowarn_unused_function, yeccpars2_114_/1}). +-file("src/future_elixir_parser.yrl", 438). +yeccpars2_114_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_115_/1}). +-dialyzer({nowarn_function, yeccpars2_115_/1}). +-compile({nowarn_unused_function, yeccpars2_115_/1}). +-file("src/future_elixir_parser.yrl", 435). +yeccpars2_115_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_116_/1}). +-dialyzer({nowarn_function, yeccpars2_116_/1}). +-compile({nowarn_unused_function, yeccpars2_116_/1}). +-file("src/future_elixir_parser.yrl", 402). +yeccpars2_116_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_117_/1}). +-dialyzer({nowarn_function, yeccpars2_117_/1}). +-compile({nowarn_unused_function, yeccpars2_117_/1}). +-file("src/future_elixir_parser.yrl", 408). +yeccpars2_117_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_118_/1}). +-dialyzer({nowarn_function, yeccpars2_118_/1}). +-compile({nowarn_unused_function, yeccpars2_118_/1}). +-file("src/future_elixir_parser.yrl", 432). +yeccpars2_118_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_119_/1}). +-dialyzer({nowarn_function, yeccpars2_119_/1}). +-compile({nowarn_unused_function, yeccpars2_119_/1}). +-file("src/future_elixir_parser.yrl", 426). +yeccpars2_119_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_120_/1}). +-dialyzer({nowarn_function, yeccpars2_120_/1}). +-compile({nowarn_unused_function, yeccpars2_120_/1}). +-file("src/future_elixir_parser.yrl", 411). +yeccpars2_120_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_121_/1}). +-dialyzer({nowarn_function, yeccpars2_121_/1}). +-compile({nowarn_unused_function, yeccpars2_121_/1}). +-file("src/future_elixir_parser.yrl", 417). +yeccpars2_121_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_122_/1}). +-dialyzer({nowarn_function, yeccpars2_122_/1}). +-compile({nowarn_unused_function, yeccpars2_122_/1}). +-file("src/future_elixir_parser.yrl", 453). +yeccpars2_122_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_123_/1}). +-dialyzer({nowarn_function, yeccpars2_123_/1}). +-compile({nowarn_unused_function, yeccpars2_123_/1}). +-file("src/future_elixir_parser.yrl", 420). +yeccpars2_123_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_124_/1}). +-dialyzer({nowarn_function, yeccpars2_124_/1}). +-compile({nowarn_unused_function, yeccpars2_124_/1}). +-file("src/future_elixir_parser.yrl", 441). +yeccpars2_124_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_125_/1}). +-dialyzer({nowarn_function, yeccpars2_125_/1}). +-compile({nowarn_unused_function, yeccpars2_125_/1}). +-file("src/future_elixir_parser.yrl", 444). +yeccpars2_125_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_126_/1}). +-dialyzer({nowarn_function, yeccpars2_126_/1}). +-compile({nowarn_unused_function, yeccpars2_126_/1}). +-file("src/future_elixir_parser.yrl", 423). +yeccpars2_126_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_127_/1}). +-dialyzer({nowarn_function, yeccpars2_127_/1}). +-compile({nowarn_unused_function, yeccpars2_127_/1}). +-file("src/future_elixir_parser.yrl", 424). +yeccpars2_127_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_128_/1}). +-dialyzer({nowarn_function, yeccpars2_128_/1}). +-compile({nowarn_unused_function, yeccpars2_128_/1}). +-file("src/future_elixir_parser.yrl", 445). +yeccpars2_128_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_129_/1}). +-dialyzer({nowarn_function, yeccpars2_129_/1}). +-compile({nowarn_unused_function, yeccpars2_129_/1}). +-file("src/future_elixir_parser.yrl", 442). +yeccpars2_129_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_130_/1}). +-dialyzer({nowarn_function, yeccpars2_130_/1}). +-compile({nowarn_unused_function, yeccpars2_130_/1}). +-file("src/future_elixir_parser.yrl", 421). +yeccpars2_130_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_131_/1}). +-dialyzer({nowarn_function, yeccpars2_131_/1}). +-compile({nowarn_unused_function, yeccpars2_131_/1}). +-file("src/future_elixir_parser.yrl", 454). +yeccpars2_131_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_132_/1}). +-dialyzer({nowarn_function, yeccpars2_132_/1}). +-compile({nowarn_unused_function, yeccpars2_132_/1}). +-file("src/future_elixir_parser.yrl", 418). +yeccpars2_132_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_133_/1}). +-dialyzer({nowarn_function, yeccpars2_133_/1}). +-compile({nowarn_unused_function, yeccpars2_133_/1}). +-file("src/future_elixir_parser.yrl", 412). +yeccpars2_133_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_134_/1}). +-dialyzer({nowarn_function, yeccpars2_134_/1}). +-compile({nowarn_unused_function, yeccpars2_134_/1}). +-file("src/future_elixir_parser.yrl", 427). +yeccpars2_134_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_135_/1}). +-dialyzer({nowarn_function, yeccpars2_135_/1}). +-compile({nowarn_unused_function, yeccpars2_135_/1}). +-file("src/future_elixir_parser.yrl", 433). +yeccpars2_135_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_136_/1}). +-dialyzer({nowarn_function, yeccpars2_136_/1}). +-compile({nowarn_unused_function, yeccpars2_136_/1}). +-file("src/future_elixir_parser.yrl", 409). +yeccpars2_136_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_137_/1}). +-dialyzer({nowarn_function, yeccpars2_137_/1}). +-compile({nowarn_unused_function, yeccpars2_137_/1}). +-file("src/future_elixir_parser.yrl", 403). +yeccpars2_137_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_138_/1}). +-dialyzer({nowarn_function, yeccpars2_138_/1}). +-compile({nowarn_unused_function, yeccpars2_138_/1}). +-file("src/future_elixir_parser.yrl", 436). +yeccpars2_138_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_139_/1}). +-dialyzer({nowarn_function, yeccpars2_139_/1}). +-compile({nowarn_unused_function, yeccpars2_139_/1}). +-file("src/future_elixir_parser.yrl", 439). +yeccpars2_139_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_140_/1}). +-dialyzer({nowarn_function, yeccpars2_140_/1}). +-compile({nowarn_unused_function, yeccpars2_140_/1}). +-file("src/future_elixir_parser.yrl", 406). +yeccpars2_140_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_141_/1}). +-dialyzer({nowarn_function, yeccpars2_141_/1}). +-compile({nowarn_unused_function, yeccpars2_141_/1}). +-file("src/future_elixir_parser.yrl", 415). +yeccpars2_141_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_142_/1}). +-dialyzer({nowarn_function, yeccpars2_142_/1}). +-compile({nowarn_unused_function, yeccpars2_142_/1}). +-file("src/future_elixir_parser.yrl", 451). +yeccpars2_142_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_143_/1}). +-dialyzer({nowarn_function, yeccpars2_143_/1}). +-compile({nowarn_unused_function, yeccpars2_143_/1}). +-file("src/future_elixir_parser.yrl", 457). +yeccpars2_143_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_144_/1}). +-dialyzer({nowarn_function, yeccpars2_144_/1}). +-compile({nowarn_unused_function, yeccpars2_144_/1}). +-file("src/future_elixir_parser.yrl", 430). +yeccpars2_144_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_145_/1}). +-dialyzer({nowarn_function, yeccpars2_145_/1}). +-compile({nowarn_unused_function, yeccpars2_145_/1}). +-file("src/future_elixir_parser.yrl", 462). +yeccpars2_145_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_146_/1}). +-dialyzer({nowarn_function, yeccpars2_146_/1}). +-compile({nowarn_unused_function, yeccpars2_146_/1}). +-file("src/future_elixir_parser.yrl", 206). +yeccpars2_146_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_147_/1}). +-dialyzer({nowarn_function, yeccpars2_147_/1}). +-compile({nowarn_unused_function, yeccpars2_147_/1}). +-file("src/future_elixir_parser.yrl", 225). +yeccpars2_147_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_148_/1}). +-dialyzer({nowarn_function, yeccpars2_148_/1}). +-compile({nowarn_unused_function, yeccpars2_148_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_148_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_149_/1}). +-dialyzer({nowarn_function, yeccpars2_149_/1}). +-compile({nowarn_unused_function, yeccpars2_149_/1}). +-file("src/future_elixir_parser.yrl", 152). +yeccpars2_149_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_150_/1}). +-dialyzer({nowarn_function, yeccpars2_150_/1}). +-compile({nowarn_unused_function, yeccpars2_150_/1}). +-file("src/future_elixir_parser.yrl", 153). +yeccpars2_150_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_no_parens_after_do_op(___2), build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_151_/1}). +-dialyzer({nowarn_function, yeccpars2_151_/1}). +-compile({nowarn_unused_function, yeccpars2_151_/1}). +-file("src/future_elixir_parser.yrl", 151). +yeccpars2_151_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_152_/1}). +-dialyzer({nowarn_function, yeccpars2_152_/1}). +-compile({nowarn_unused_function, yeccpars2_152_/1}). +-file("src/future_elixir_parser.yrl", 215). +yeccpars2_152_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_153_/1}). +-dialyzer({nowarn_function, yeccpars2_153_/1}). +-compile({nowarn_unused_function, yeccpars2_153_/1}). +-file("src/future_elixir_parser.yrl", 196). +yeccpars2_153_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_pipe(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_154_/1}). +-dialyzer({nowarn_function, yeccpars2_154_/1}). +-compile({nowarn_unused_function, yeccpars2_154_/1}). +-file("src/future_elixir_parser.yrl", 234). +yeccpars2_154_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_pipe(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_155_/1}). +-dialyzer({nowarn_function, yeccpars2_155_/1}). +-compile({nowarn_unused_function, yeccpars2_155_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_155_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_156_/1}). +-dialyzer({nowarn_function, yeccpars2_156_/1}). +-compile({nowarn_unused_function, yeccpars2_156_/1}). +-file("src/future_elixir_parser.yrl", 213). +yeccpars2_156_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_157_/1}). +-dialyzer({nowarn_function, yeccpars2_157_/1}). +-compile({nowarn_unused_function, yeccpars2_157_/1}). +-file("src/future_elixir_parser.yrl", 232). +yeccpars2_157_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_158_/1}). +-dialyzer({nowarn_function, yeccpars2_158_/1}). +-compile({nowarn_unused_function, yeccpars2_158_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_158_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_159_/1}). +-dialyzer({nowarn_function, yeccpars2_159_/1}). +-compile({nowarn_unused_function, yeccpars2_159_/1}). +-file("src/future_elixir_parser.yrl", 202). +yeccpars2_159_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_160_/1}). +-dialyzer({nowarn_function, yeccpars2_160_/1}). +-compile({nowarn_unused_function, yeccpars2_160_/1}). +-file("src/future_elixir_parser.yrl", 221). +yeccpars2_160_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_161_/1}). +-dialyzer({nowarn_function, yeccpars2_161_/1}). +-compile({nowarn_unused_function, yeccpars2_161_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_161_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_163_/1}). +-dialyzer({nowarn_function, yeccpars2_163_/1}). +-compile({nowarn_unused_function, yeccpars2_163_/1}). +-file("src/future_elixir_parser.yrl", 468). +yeccpars2_163_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_alias(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_164_/1}). +-dialyzer({nowarn_function, yeccpars2_164_/1}). +-compile({nowarn_unused_function, yeccpars2_164_/1}). +-file("src/future_elixir_parser.yrl", 479). +yeccpars2_164_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_165_/1}). +-dialyzer({nowarn_function, yeccpars2_165_/1}). +-compile({nowarn_unused_function, yeccpars2_165_/1}). +-file("src/future_elixir_parser.yrl", 476). +yeccpars2_165_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_166_/1}). +-dialyzer({nowarn_function, yeccpars2_166_/1}). +-compile({nowarn_unused_function, yeccpars2_166_/1}). +-file("src/future_elixir_parser.yrl", 465). +yeccpars2_166_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_167_/1}). +-dialyzer({nowarn_function, yeccpars2_167_/1}). +-compile({nowarn_unused_function, yeccpars2_167_/1}). +-file("src/future_elixir_parser.yrl", 473). +yeccpars2_167_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_168_/1}). +-dialyzer({nowarn_function, yeccpars2_168_/1}). +-compile({nowarn_unused_function, yeccpars2_168_/1}). +-file("src/future_elixir_parser.yrl", 482). +yeccpars2_168_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_169_/1}). +-dialyzer({nowarn_function, yeccpars2_169_/1}). +-compile({nowarn_unused_function, yeccpars2_169_/1}). +-file("src/future_elixir_parser.yrl", 521). +yeccpars2_169_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_170_/1}). +-dialyzer({nowarn_function, yeccpars2_170_/1}). +-compile({nowarn_unused_function, yeccpars2_170_/1}). +-file("src/future_elixir_parser.yrl", 522). +yeccpars2_170_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_container_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_171_/1}). +-dialyzer({nowarn_function, yeccpars2_171_/1}). +-compile({nowarn_unused_function, yeccpars2_171_/1}). +-file("src/future_elixir_parser.yrl", 520). +yeccpars2_171_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_172_/1}). +-dialyzer({nowarn_function, yeccpars2_172_/1}). +-compile({nowarn_unused_function, yeccpars2_172_/1}). +-file("src/future_elixir_parser.yrl", 524). +yeccpars2_172_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_173_/1}). +-dialyzer({nowarn_function, yeccpars2_173_/1}). +-compile({nowarn_unused_function, yeccpars2_173_/1}). +-file("src/future_elixir_parser.yrl", 527). +yeccpars2_173_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_175_/1}). +-dialyzer({nowarn_function, yeccpars2_175_/1}). +-compile({nowarn_unused_function, yeccpars2_175_/1}). +-file("src/future_elixir_parser.yrl", 469). +yeccpars2_175_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_container(___2, ___1, [], []) + end | __Stack]. + +-compile({inline,yeccpars2_176_/1}). +-dialyzer({nowarn_function, yeccpars2_176_/1}). +-compile({nowarn_unused_function, yeccpars2_176_/1}). +-file("src/future_elixir_parser.yrl", 470). +yeccpars2_176_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_container(___2, ___1, ___4, newlines_pair(___3, ___5)) + end | __Stack]. + +-compile({inline,yeccpars2_178_/1}). +-dialyzer({nowarn_function, yeccpars2_178_/1}). +-compile({nowarn_unused_function, yeccpars2_178_/1}). +-file("src/future_elixir_parser.yrl", 384). +yeccpars2_178_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_179_/1}). +-dialyzer({nowarn_function, yeccpars2_179_/1}). +-compile({nowarn_unused_function, yeccpars2_179_/1}). +-file("src/future_elixir_parser.yrl", 385). +yeccpars2_179_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_180_/1}). +-dialyzer({nowarn_function, yeccpars2_180_/1}). +-compile({nowarn_unused_function, yeccpars2_180_/1}). +-file("src/future_elixir_parser.yrl", 528). +yeccpars2_180_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_182_/1}). +-dialyzer({nowarn_function, yeccpars2_182_/1}). +-compile({nowarn_unused_function, yeccpars2_182_/1}). +-file("src/future_elixir_parser.yrl", 529). +yeccpars2_182_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse([___3 | ___1]) + end | __Stack]. + +-compile({inline,yeccpars2_183_/1}). +-dialyzer({nowarn_function, yeccpars2_183_/1}). +-compile({nowarn_unused_function, yeccpars2_183_/1}). +-file("src/future_elixir_parser.yrl", 567). +yeccpars2_183_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_184_/1}). +-dialyzer({nowarn_function, yeccpars2_184_/1}). +-compile({nowarn_unused_function, yeccpars2_184_/1}). +-file("src/future_elixir_parser.yrl", 525). +yeccpars2_184_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-file("src/future_elixir_parser.erl", 28791). +-compile({inline,yeccpars2_185_/1}). +-dialyzer({nowarn_function, yeccpars2_185_/1}). +-compile({nowarn_unused_function, yeccpars2_185_/1}). +-file("src/future_elixir_parser.yrl", 553). +yeccpars2_185_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_186_/1}). +-dialyzer({nowarn_function, yeccpars2_186_/1}). +-compile({nowarn_unused_function, yeccpars2_186_/1}). +-file("src/future_elixir_parser.yrl", 555). +yeccpars2_186_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_187_/1}). +-dialyzer({nowarn_function, yeccpars2_187_/1}). +-compile({nowarn_unused_function, yeccpars2_187_/1}). +-file("src/future_elixir_parser.yrl", 557). +yeccpars2_187_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_188_/1}). +-dialyzer({nowarn_function, yeccpars2_188_/1}). +-compile({nowarn_unused_function, yeccpars2_188_/1}). +-file("src/future_elixir_parser.yrl", 558). +yeccpars2_188_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_189_/1}). +-dialyzer({nowarn_function, yeccpars2_189_/1}). +-compile({nowarn_unused_function, yeccpars2_189_/1}). +-file("src/future_elixir_parser.yrl", 556). +yeccpars2_189_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, [{format, keyword}]) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 28842). +-compile({inline,yeccpars2_190_/1}). +-dialyzer({nowarn_function, yeccpars2_190_/1}). +-compile({nowarn_unused_function, yeccpars2_190_/1}). +-file("src/future_elixir_parser.yrl", 554). +yeccpars2_190_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_191_/1}). +-dialyzer({nowarn_function, yeccpars2_191_/1}). +-compile({nowarn_unused_function, yeccpars2_191_/1}). +-file("src/future_elixir_parser.yrl", 568). +yeccpars2_191_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_193_/1}). +-dialyzer({nowarn_function, yeccpars2_193_/1}). +-compile({nowarn_unused_function, yeccpars2_193_/1}). +-file("src/future_elixir_parser.yrl", 569). +yeccpars2_193_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_data_follow_up(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_196_/1}). +-dialyzer({nowarn_function, yeccpars2_196_/1}). +-compile({nowarn_unused_function, yeccpars2_196_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_196_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_197_/1}). +-dialyzer({nowarn_function, yeccpars2_197_/1}). +-compile({nowarn_unused_function, yeccpars2_197_/1}). +-file("src/future_elixir_parser.yrl", 247). +yeccpars2_197_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_201_/1}). +-dialyzer({nowarn_function, yeccpars2_201_/1}). +-compile({nowarn_unused_function, yeccpars2_201_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_201_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_202_/1}). +-dialyzer({nowarn_function, yeccpars2_202_/1}). +-compile({nowarn_unused_function, yeccpars2_202_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_202_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_221_/1}). +-dialyzer({nowarn_function, yeccpars2_221_/1}). +-compile({nowarn_unused_function, yeccpars2_221_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_221_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_222_/1}). +-dialyzer({nowarn_function, yeccpars2_222_/1}). +-compile({nowarn_unused_function, yeccpars2_222_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_222_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_223_/1}). +-dialyzer({nowarn_function, yeccpars2_223_/1}). +-compile({nowarn_unused_function, yeccpars2_223_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_223_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_224_/1}). +-dialyzer({nowarn_function, yeccpars2_224_/1}). +-compile({nowarn_unused_function, yeccpars2_224_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_224_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_225_/1}). +-dialyzer({nowarn_function, yeccpars2_225_/1}). +-compile({nowarn_unused_function, yeccpars2_225_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_225_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_226_/1}). +-dialyzer({nowarn_function, yeccpars2_226_/1}). +-compile({nowarn_unused_function, yeccpars2_226_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_226_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_227_/1}). +-dialyzer({nowarn_function, yeccpars2_227_/1}). +-compile({nowarn_unused_function, yeccpars2_227_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_227_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_228_/1}). +-dialyzer({nowarn_function, yeccpars2_228_/1}). +-compile({nowarn_unused_function, yeccpars2_228_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_228_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_229_/1}). +-dialyzer({nowarn_function, yeccpars2_229_/1}). +-compile({nowarn_unused_function, yeccpars2_229_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_229_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_230_/1}). +-dialyzer({nowarn_function, yeccpars2_230_/1}). +-compile({nowarn_unused_function, yeccpars2_230_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_230_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_231_/1}). +-dialyzer({nowarn_function, yeccpars2_231_/1}). +-compile({nowarn_unused_function, yeccpars2_231_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_231_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_232_/1}). +-dialyzer({nowarn_function, yeccpars2_232_/1}). +-compile({nowarn_unused_function, yeccpars2_232_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_232_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_233_/1}). +-dialyzer({nowarn_function, yeccpars2_233_/1}). +-compile({nowarn_unused_function, yeccpars2_233_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_233_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_234_/1}). +-dialyzer({nowarn_function, yeccpars2_234_/1}). +-compile({nowarn_unused_function, yeccpars2_234_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_234_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_235_/1}). +-dialyzer({nowarn_function, yeccpars2_235_/1}). +-compile({nowarn_unused_function, yeccpars2_235_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_235_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_236_/1}). +-dialyzer({nowarn_function, yeccpars2_236_/1}). +-compile({nowarn_unused_function, yeccpars2_236_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_236_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_237_/1}). +-dialyzer({nowarn_function, yeccpars2_237_/1}). +-compile({nowarn_unused_function, yeccpars2_237_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_237_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_238_/1}). +-dialyzer({nowarn_function, yeccpars2_238_/1}). +-compile({nowarn_unused_function, yeccpars2_238_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_238_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_239_/1}). +-dialyzer({nowarn_function, yeccpars2_239_/1}). +-compile({nowarn_unused_function, yeccpars2_239_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_239_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_241_/1}). +-dialyzer({nowarn_function, yeccpars2_241_/1}). +-compile({nowarn_unused_function, yeccpars2_241_/1}). +-file("src/future_elixir_parser.yrl", 253). +yeccpars2_241_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_243_/1}). +-dialyzer({nowarn_function, yeccpars2_243_/1}). +-compile({nowarn_unused_function, yeccpars2_243_/1}). +-file("src/future_elixir_parser.yrl", 304). +yeccpars2_243_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_access(build_unary_op(___1, ___2), meta_with_from_brackets(___3)) + end | __Stack]. + +-compile({inline,yeccpars2_244_/1}). +-dialyzer({nowarn_function, yeccpars2_244_/1}). +-compile({nowarn_unused_function, yeccpars2_244_/1}). +-file("src/future_elixir_parser.yrl", 254). +yeccpars2_244_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + error_invalid_kw_identifier(___2) + end | __Stack]. + +-compile({inline,yeccpars2_247_/1}). +-dialyzer({nowarn_function, yeccpars2_247_/1}). +-compile({nowarn_unused_function, yeccpars2_247_/1}). +-file("src/future_elixir_parser.yrl", 295). +yeccpars2_247_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_249_/1}). +-dialyzer({nowarn_function, yeccpars2_249_/1}). +-compile({nowarn_unused_function, yeccpars2_249_/1}). +-file("src/future_elixir_parser.yrl", 374). +yeccpars2_249_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_251_/1}). +-dialyzer({nowarn_function, yeccpars2_251_/1}). +-compile({nowarn_unused_function, yeccpars2_251_/1}). +-file("src/future_elixir_parser.yrl", 375). +yeccpars2_251_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_253_/1}). +-dialyzer({nowarn_function, yeccpars2_253_/1}). +-compile({nowarn_unused_function, yeccpars2_253_/1}). +-file("src/future_elixir_parser.yrl", 296). +yeccpars2_253_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_254_/1}). +-dialyzer({nowarn_function, yeccpars2_254_/1}). +-compile({nowarn_unused_function, yeccpars2_254_/1}). +-file("src/future_elixir_parser.yrl", 297). +yeccpars2_254_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + error_too_many_access_syntax(___3) + end | __Stack]. + +-compile({inline,yeccpars2_255_/1}). +-dialyzer({nowarn_function, yeccpars2_255_/1}). +-compile({nowarn_unused_function, yeccpars2_255_/1}). +-file("src/future_elixir_parser.yrl", 294). +yeccpars2_255_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_256_/1}). +-dialyzer({nowarn_function, yeccpars2_256_/1}). +-compile({nowarn_unused_function, yeccpars2_256_/1}). +-file("src/future_elixir_parser.yrl", 302). +yeccpars2_256_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_access(build_unary_op(___1, build_identifier(___2)), meta_with_from_brackets(___3)) + end | __Stack]. + +-compile({inline,yeccpars2_257_/1}). +-dialyzer({nowarn_function, yeccpars2_257_/1}). +-compile({nowarn_unused_function, yeccpars2_257_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_257_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_259_/1}). +-dialyzer({nowarn_function, yeccpars2_259_/1}). +-compile({nowarn_unused_function, yeccpars2_259_/1}). +-file("src/future_elixir_parser.yrl", 291). +yeccpars2_259_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_260_/1}). +-dialyzer({nowarn_function, yeccpars2_260_/1}). +-compile({nowarn_unused_function, yeccpars2_260_/1}). +-file("src/future_elixir_parser.yrl", 292). +yeccpars2_260_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_261_/1}). +-dialyzer({nowarn_function, yeccpars2_261_/1}). +-compile({nowarn_unused_function, yeccpars2_261_/1}). +-file("src/future_elixir_parser.yrl", 534). +yeccpars2_261_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_262_/1}). +-dialyzer({nowarn_function, yeccpars2_262_/1}). +-compile({nowarn_unused_function, yeccpars2_262_/1}). +-file("src/future_elixir_parser.yrl", 535). +yeccpars2_262_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_263_/1}). +-dialyzer({nowarn_function, yeccpars2_263_/1}). +-compile({nowarn_unused_function, yeccpars2_263_/1}). +-file("src/future_elixir_parser.yrl", 533). +yeccpars2_263_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_265_/1}). +-dialyzer({nowarn_function, yeccpars2_265_/1}). +-compile({nowarn_unused_function, yeccpars2_265_/1}). +-file("src/future_elixir_parser.yrl", 563). +yeccpars2_265_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_266_/1}). +-dialyzer({nowarn_function, yeccpars2_266_/1}). +-compile({nowarn_unused_function, yeccpars2_266_/1}). +-file("src/future_elixir_parser.yrl", 537). +yeccpars2_266_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_268_/1}). +-dialyzer({nowarn_function, yeccpars2_268_/1}). +-compile({nowarn_unused_function, yeccpars2_268_/1}). +-file("src/future_elixir_parser.yrl", 540). +yeccpars2_268_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___2), []} + end | __Stack]. + +-compile({inline,yeccpars2_269_/1}). +-dialyzer({nowarn_function, yeccpars2_269_/1}). +-compile({nowarn_unused_function, yeccpars2_269_/1}). +-file("src/future_elixir_parser.yrl", 546). +yeccpars2_269_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), reverse(___2)} + end | __Stack]. + +-compile({inline,yeccpars2_270_/1}). +-dialyzer({nowarn_function, yeccpars2_270_/1}). +-compile({nowarn_unused_function, yeccpars2_270_/1}). +-file("src/future_elixir_parser.yrl", 367). +yeccpars2_270_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_273_/1}). +-dialyzer({nowarn_function, yeccpars2_273_/1}). +-compile({nowarn_unused_function, yeccpars2_273_/1}). +-file("src/future_elixir_parser.yrl", 368). +yeccpars2_273_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_274_/1}). +-dialyzer({nowarn_function, yeccpars2_274_/1}). +-compile({nowarn_unused_function, yeccpars2_274_/1}). +-file("src/future_elixir_parser.yrl", 535). +yeccpars2_274_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_276_/1}). +-dialyzer({nowarn_function, yeccpars2_276_/1}). +-compile({nowarn_unused_function, yeccpars2_276_/1}). +-file("src/future_elixir_parser.yrl", 538). +yeccpars2_276_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_277_/1}). +-dialyzer({nowarn_function, yeccpars2_277_/1}). +-compile({nowarn_unused_function, yeccpars2_277_/1}). +-file("src/future_elixir_parser.yrl", 548). +yeccpars2_277_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___5), reverse([___4 | ___2])} + end | __Stack]. + +-compile({inline,yeccpars2_278_/1}). +-dialyzer({nowarn_function, yeccpars2_278_/1}). +-compile({nowarn_unused_function, yeccpars2_278_/1}). +-file("src/future_elixir_parser.yrl", 564). +yeccpars2_278_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_trailing_comma(___2), reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_279_/1}). +-dialyzer({nowarn_function, yeccpars2_279_/1}). +-compile({nowarn_unused_function, yeccpars2_279_/1}). +-file("src/future_elixir_parser.yrl", 565). +yeccpars2_279_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_call_follow_up(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_280_/1}). +-dialyzer({nowarn_function, yeccpars2_280_/1}). +-compile({nowarn_unused_function, yeccpars2_280_/1}). +-file("src/future_elixir_parser.yrl", 544). +yeccpars2_280_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), [___2]} + end | __Stack]. + +-compile({inline,yeccpars2_281_/1}). +-dialyzer({nowarn_function, yeccpars2_281_/1}). +-compile({nowarn_unused_function, yeccpars2_281_/1}). +-file("src/future_elixir_parser.yrl", 542). +yeccpars2_281_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), [___2]} + end | __Stack]. + +-compile({inline,yeccpars2_282_/1}). +-dialyzer({nowarn_function, yeccpars2_282_/1}). +-compile({nowarn_unused_function, yeccpars2_282_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_282_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_284_/1}). +-dialyzer({nowarn_function, yeccpars2_284_/1}). +-compile({nowarn_unused_function, yeccpars2_284_/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_284_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_285_/1}). +-dialyzer({nowarn_function, yeccpars2_285_/1}). +-compile({nowarn_unused_function, yeccpars2_285_/1}). +-file("src/future_elixir_parser.yrl", 574). +yeccpars2_285_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_286_/1}). +-dialyzer({nowarn_function, yeccpars2_286_/1}). +-compile({nowarn_unused_function, yeccpars2_286_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_286_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_288_/1}). +-dialyzer({nowarn_function, yeccpars2_288_/1}). +-compile({nowarn_unused_function, yeccpars2_288_/1}). +-file("src/future_elixir_parser.yrl", 576). +yeccpars2_288_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_call_follow_up(___2, [___1], ___3) + end | __Stack]. + +-compile({inline,yeccpars2_289_/1}). +-dialyzer({nowarn_function, yeccpars2_289_/1}). +-compile({nowarn_unused_function, yeccpars2_289_/1}). +-file("src/future_elixir_parser.yrl", 575). +yeccpars2_289_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___1 | ___3] + end | __Stack]. + +-compile({inline,yeccpars2_291_/1}). +-dialyzer({nowarn_function, yeccpars2_291_/1}). +-compile({nowarn_unused_function, yeccpars2_291_/1}). +-file("src/future_elixir_parser.yrl", 572). +yeccpars2_291_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_nested_no_parens_keyword(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_292_/1}). +-dialyzer({nowarn_function, yeccpars2_292_/1}). +-compile({nowarn_unused_function, yeccpars2_292_/1}). +-file("src/future_elixir_parser.yrl", 571). +yeccpars2_292_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_294_/1}). +-dialyzer({nowarn_function, yeccpars2_294_/1}). +-compile({nowarn_unused_function, yeccpars2_294_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_294_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_297_/1}). +-dialyzer({nowarn_function, yeccpars2_297_/1}). +-compile({nowarn_unused_function, yeccpars2_297_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_297_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_298_/1}). +-dialyzer({nowarn_function, yeccpars2_298_/1}). +-compile({nowarn_unused_function, yeccpars2_298_/1}). +-file("src/future_elixir_parser.yrl", 164). +yeccpars2_298_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_299_/1}). +-dialyzer({nowarn_function, yeccpars2_299_/1}). +-compile({nowarn_unused_function, yeccpars2_299_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_299_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_318_/1}). +-dialyzer({nowarn_function, yeccpars2_318_/1}). +-compile({nowarn_unused_function, yeccpars2_318_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_318_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_319_/1}). +-dialyzer({nowarn_function, yeccpars2_319_/1}). +-compile({nowarn_unused_function, yeccpars2_319_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_319_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_320_/1}). +-dialyzer({nowarn_function, yeccpars2_320_/1}). +-compile({nowarn_unused_function, yeccpars2_320_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_320_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_321_/1}). +-dialyzer({nowarn_function, yeccpars2_321_/1}). +-compile({nowarn_unused_function, yeccpars2_321_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_321_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_322_/1}). +-dialyzer({nowarn_function, yeccpars2_322_/1}). +-compile({nowarn_unused_function, yeccpars2_322_/1}). +-file("src/future_elixir_parser.yrl", 218). +yeccpars2_322_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_323_/1}). +-dialyzer({nowarn_function, yeccpars2_323_/1}). +-compile({nowarn_unused_function, yeccpars2_323_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_323_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_324_/1}). +-dialyzer({nowarn_function, yeccpars2_324_/1}). +-compile({nowarn_unused_function, yeccpars2_324_/1}). +-file("src/future_elixir_parser.yrl", 228). +yeccpars2_324_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_325_/1}). +-dialyzer({nowarn_function, yeccpars2_325_/1}). +-compile({nowarn_unused_function, yeccpars2_325_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_325_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_326_/1}). +-dialyzer({nowarn_function, yeccpars2_326_/1}). +-compile({nowarn_unused_function, yeccpars2_326_/1}). +-file("src/future_elixir_parser.yrl", 227). +yeccpars2_326_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_327_/1}). +-dialyzer({nowarn_function, yeccpars2_327_/1}). +-compile({nowarn_unused_function, yeccpars2_327_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_327_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_328_/1}). +-dialyzer({nowarn_function, yeccpars2_328_/1}). +-compile({nowarn_unused_function, yeccpars2_328_/1}). +-file("src/future_elixir_parser.yrl", 217). +yeccpars2_328_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_329_/1}). +-dialyzer({nowarn_function, yeccpars2_329_/1}). +-compile({nowarn_unused_function, yeccpars2_329_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_329_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_330_/1}). +-dialyzer({nowarn_function, yeccpars2_330_/1}). +-compile({nowarn_unused_function, yeccpars2_330_/1}). +-file("src/future_elixir_parser.yrl", 219). +yeccpars2_330_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_331_/1}). +-dialyzer({nowarn_function, yeccpars2_331_/1}). +-compile({nowarn_unused_function, yeccpars2_331_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_331_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_332_/1}). +-dialyzer({nowarn_function, yeccpars2_332_/1}). +-compile({nowarn_unused_function, yeccpars2_332_/1}). +-file("src/future_elixir_parser.yrl", 226). +yeccpars2_332_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_333_/1}). +-dialyzer({nowarn_function, yeccpars2_333_/1}). +-compile({nowarn_unused_function, yeccpars2_333_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_333_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_334_/1}). +-dialyzer({nowarn_function, yeccpars2_334_/1}). +-compile({nowarn_unused_function, yeccpars2_334_/1}). +-file("src/future_elixir_parser.yrl", 231). +yeccpars2_334_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_335_/1}). +-dialyzer({nowarn_function, yeccpars2_335_/1}). +-compile({nowarn_unused_function, yeccpars2_335_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_335_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_336_/1}). +-dialyzer({nowarn_function, yeccpars2_336_/1}). +-compile({nowarn_unused_function, yeccpars2_336_/1}). +-file("src/future_elixir_parser.yrl", 220). +yeccpars2_336_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_337_/1}). +-dialyzer({nowarn_function, yeccpars2_337_/1}). +-compile({nowarn_unused_function, yeccpars2_337_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_337_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_338_/1}). +-dialyzer({nowarn_function, yeccpars2_338_/1}). +-compile({nowarn_unused_function, yeccpars2_338_/1}). +-file("src/future_elixir_parser.yrl", 222). +yeccpars2_338_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_339_/1}). +-dialyzer({nowarn_function, yeccpars2_339_/1}). +-compile({nowarn_unused_function, yeccpars2_339_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_339_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_340_/1}). +-dialyzer({nowarn_function, yeccpars2_340_/1}). +-compile({nowarn_unused_function, yeccpars2_340_/1}). +-file("src/future_elixir_parser.yrl", 233). +yeccpars2_340_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_341_/1}). +-dialyzer({nowarn_function, yeccpars2_341_/1}). +-compile({nowarn_unused_function, yeccpars2_341_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_341_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_342_/1}). +-dialyzer({nowarn_function, yeccpars2_342_/1}). +-compile({nowarn_unused_function, yeccpars2_342_/1}). +-file("src/future_elixir_parser.yrl", 223). +yeccpars2_342_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_343_/1}). +-dialyzer({nowarn_function, yeccpars2_343_/1}). +-compile({nowarn_unused_function, yeccpars2_343_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_343_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_344_/1}). +-dialyzer({nowarn_function, yeccpars2_344_/1}). +-compile({nowarn_unused_function, yeccpars2_344_/1}). +-file("src/future_elixir_parser.yrl", 229). +yeccpars2_344_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_345_/1}). +-dialyzer({nowarn_function, yeccpars2_345_/1}). +-compile({nowarn_unused_function, yeccpars2_345_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_345_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_346_/1}). +-dialyzer({nowarn_function, yeccpars2_346_/1}). +-compile({nowarn_unused_function, yeccpars2_346_/1}). +-file("src/future_elixir_parser.yrl", 230). +yeccpars2_346_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_347_/1}). +-dialyzer({nowarn_function, yeccpars2_347_/1}). +-compile({nowarn_unused_function, yeccpars2_347_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_347_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_348_/1}). +-dialyzer({nowarn_function, yeccpars2_348_/1}). +-compile({nowarn_unused_function, yeccpars2_348_/1}). +-file("src/future_elixir_parser.yrl", 237). +yeccpars2_348_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_349_/1}). +-dialyzer({nowarn_function, yeccpars2_349_/1}). +-compile({nowarn_unused_function, yeccpars2_349_/1}). +-file("src/future_elixir_parser.yrl", 224). +yeccpars2_349_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_350_/1}). +-dialyzer({nowarn_function, yeccpars2_350_/1}). +-compile({nowarn_unused_function, yeccpars2_350_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_350_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_351_/1}). +-dialyzer({nowarn_function, yeccpars2_351_/1}). +-compile({nowarn_unused_function, yeccpars2_351_/1}). +-file("src/future_elixir_parser.yrl", 162). +yeccpars2_351_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_352_/1}). +-dialyzer({nowarn_function, yeccpars2_352_/1}). +-compile({nowarn_unused_function, yeccpars2_352_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_352_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_353_/1}). +-dialyzer({nowarn_function, yeccpars2_353_/1}). +-compile({nowarn_unused_function, yeccpars2_353_/1}). +-file("src/future_elixir_parser.yrl", 163). +yeccpars2_353_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_354_/1}). +-dialyzer({nowarn_function, yeccpars2_354_/1}). +-compile({nowarn_unused_function, yeccpars2_354_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_354_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_356_/1}). +-dialyzer({nowarn_function, yeccpars2_356_/1}). +-compile({nowarn_unused_function, yeccpars2_356_/1}). +-file("src/future_elixir_parser.yrl", 505). +yeccpars2_356_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_357_/1}). +-dialyzer({nowarn_function, yeccpars2_357_/1}). +-compile({nowarn_unused_function, yeccpars2_357_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_357_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_358_/1}). +-dialyzer({nowarn_function, yeccpars2_358_/1}). +-compile({nowarn_unused_function, yeccpars2_358_/1}). +-file("src/future_elixir_parser.yrl", 243). +yeccpars2_358_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_359_/1}). +-dialyzer({nowarn_function, yeccpars2_359_/1}). +-compile({nowarn_unused_function, yeccpars2_359_/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_359_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_360_/1}). +-dialyzer({nowarn_function, yeccpars2_360_/1}). +-compile({nowarn_unused_function, yeccpars2_360_/1}). +-file("src/future_elixir_parser.yrl", 508). +yeccpars2_360_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_361_/1}). +-dialyzer({nowarn_function, yeccpars2_361_/1}). +-compile({nowarn_unused_function, yeccpars2_361_/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_361_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_363_/1}). +-dialyzer({nowarn_function, yeccpars2_363_/1}). +-compile({nowarn_unused_function, yeccpars2_363_/1}). +-file("src/future_elixir_parser.yrl", 490). +yeccpars2_363_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_364_/1}). +-dialyzer({nowarn_function, yeccpars2_364_/1}). +-compile({nowarn_unused_function, yeccpars2_364_/1}). +-file("src/future_elixir_parser.yrl", 489). +yeccpars2_364_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_365_/1}). +-dialyzer({nowarn_function, yeccpars2_365_/1}). +-compile({nowarn_unused_function, yeccpars2_365_/1}). +-file("src/future_elixir_parser.yrl", 509). +yeccpars2_365_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse([___3 | ___1]) + end | __Stack]. + +-compile({inline,yeccpars2_366_/1}). +-dialyzer({nowarn_function, yeccpars2_366_/1}). +-compile({nowarn_unused_function, yeccpars2_366_/1}). +-file("src/future_elixir_parser.yrl", 493). +yeccpars2_366_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_368_/1}). +-dialyzer({nowarn_function, yeccpars2_368_/1}). +-compile({nowarn_unused_function, yeccpars2_368_/1}). +-file("src/future_elixir_parser.yrl", 507). +yeccpars2_368_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___1, ___3] + end | __Stack]. + +-compile({inline,yeccpars2_369_/1}). +-dialyzer({nowarn_function, yeccpars2_369_/1}). +-compile({nowarn_unused_function, yeccpars2_369_/1}). +-file("src/future_elixir_parser.yrl", 492). +yeccpars2_369_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3, ___1] + end | __Stack]. + +-compile({inline,yeccpars2_371_/1}). +-dialyzer({nowarn_function, yeccpars2_371_/1}). +-compile({nowarn_unused_function, yeccpars2_371_/1}). +-file("src/future_elixir_parser.yrl", 339). +yeccpars2_371_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + build_op([], ___1) + end | __Stack]. + +-compile({inline,yeccpars2_372_/1}). +-dialyzer({nowarn_function, yeccpars2_372_/1}). +-compile({nowarn_unused_function, yeccpars2_372_/1}). +-file("src/future_elixir_parser.yrl", 353). +yeccpars2_372_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_stab_clause(___1), {___1, handle_literal(nil, ___1)} + end | __Stack]. + +-compile({inline,yeccpars2_373_/1}). +-dialyzer({nowarn_function, yeccpars2_373_/1}). +-compile({nowarn_unused_function, yeccpars2_373_/1}). +-file("src/future_elixir_parser.yrl", 331). +yeccpars2_373_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_375_/1}). +-dialyzer({nowarn_function, yeccpars2_375_/1}). +-compile({nowarn_unused_function, yeccpars2_375_/1}). +-file("src/future_elixir_parser.yrl", 334). +yeccpars2_375_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_377_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_377_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_377_)'/1}). +-file("src/future_elixir_parser.yrl", 100). +'yeccpars2_377_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_377_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_377_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_377_;'/1}). +-file("src/future_elixir_parser.yrl", 100). +'yeccpars2_377_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_377_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_377_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_end/1}). +-dialyzer({nowarn_function, yeccpars2_377_end/1}). +-compile({nowarn_unused_function, yeccpars2_377_end/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_eol/1}). +-dialyzer({nowarn_function, yeccpars2_377_eol/1}). +-compile({nowarn_unused_function, yeccpars2_377_eol/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_/1}). +-dialyzer({nowarn_function, yeccpars2_377_/1}). +-compile({nowarn_unused_function, yeccpars2_377_/1}). +-file("src/future_elixir_parser.yrl", 505). +yeccpars2_377_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,'yeccpars2_378_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_378_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_378_)'/1}). +-file("src/future_elixir_parser.yrl", 99). +'yeccpars2_378_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_378_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_378_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_378_;'/1}). +-file("src/future_elixir_parser.yrl", 99). +'yeccpars2_378_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_378_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_378_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_end/1}). +-dialyzer({nowarn_function, yeccpars2_378_end/1}). +-compile({nowarn_unused_function, yeccpars2_378_end/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_eol/1}). +-dialyzer({nowarn_function, yeccpars2_378_eol/1}). +-compile({nowarn_unused_function, yeccpars2_378_eol/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_/1}). +-dialyzer({nowarn_function, yeccpars2_378_/1}). +-compile({nowarn_unused_function, yeccpars2_378_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_378_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_379_/1}). +-dialyzer({nowarn_function, yeccpars2_379_/1}). +-compile({nowarn_unused_function, yeccpars2_379_/1}). +-file("src/future_elixir_parser.yrl", 337). +yeccpars2_379_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_380_/1}). +-dialyzer({nowarn_function, yeccpars2_380_/1}). +-compile({nowarn_unused_function, yeccpars2_380_/1}). +-file("src/future_elixir_parser.yrl", 267). +yeccpars2_380_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_paren(___1), {'__block__', [], []} + end | __Stack]. + +-compile({inline,yeccpars2_381_/1}). +-dialyzer({nowarn_function, yeccpars2_381_/1}). +-compile({nowarn_unused_function, yeccpars2_381_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_381_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_382_/1}). +-dialyzer({nowarn_function, yeccpars2_382_/1}). +-compile({nowarn_unused_function, yeccpars2_382_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_382_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_383_/1}). +-dialyzer({nowarn_function, yeccpars2_383_/1}). +-compile({nowarn_unused_function, yeccpars2_383_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_383_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_384_/1}). +-dialyzer({nowarn_function, yeccpars2_384_/1}). +-compile({nowarn_unused_function, yeccpars2_384_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_384_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_386_/1}). +-dialyzer({nowarn_function, yeccpars2_386_/1}). +-compile({nowarn_unused_function, yeccpars2_386_/1}). +-file("src/future_elixir_parser.yrl", 370). +yeccpars2_386_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_388_/1}). +-dialyzer({nowarn_function, yeccpars2_388_/1}). +-compile({nowarn_unused_function, yeccpars2_388_/1}). +-file("src/future_elixir_parser.yrl", 447). +yeccpars2_388_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_389_/1}). +-dialyzer({nowarn_function, yeccpars2_389_/1}). +-compile({nowarn_unused_function, yeccpars2_389_/1}). +-file("src/future_elixir_parser.yrl", 448). +yeccpars2_389_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_391_/1}). +-dialyzer({nowarn_function, yeccpars2_391_/1}). +-compile({nowarn_unused_function, yeccpars2_391_/1}). +-file("src/future_elixir_parser.yrl", 266). +yeccpars2_391_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, [], ___3) + end | __Stack]. + +-compile({inline,yeccpars2_392_/1}). +-dialyzer({nowarn_function, yeccpars2_392_/1}). +-compile({nowarn_unused_function, yeccpars2_392_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_392_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_393_/1}). +-dialyzer({nowarn_function, yeccpars2_393_/1}). +-compile({nowarn_unused_function, yeccpars2_393_/1}). +-file("src/future_elixir_parser.yrl", 265). +yeccpars2_393_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, ___3, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_394_/1}). +-dialyzer({nowarn_function, yeccpars2_394_/1}). +-compile({nowarn_unused_function, yeccpars2_394_/1}). +-file("src/future_elixir_parser.yrl", 345). +yeccpars2_394_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op(unwrap_when(unwrap_splice(___1)), ___2) + end | __Stack]. + +-compile({inline,yeccpars2_395_/1}). +-dialyzer({nowarn_function, yeccpars2_395_/1}). +-compile({nowarn_unused_function, yeccpars2_395_/1}). +-file("src/future_elixir_parser.yrl", 512). +yeccpars2_395_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + error_no_parens_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_396_/1}). +-dialyzer({nowarn_function, yeccpars2_396_/1}). +-compile({nowarn_unused_function, yeccpars2_396_/1}). +-file("src/future_elixir_parser.yrl", 513). +yeccpars2_396_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + error_no_parens_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_397_/1}). +-dialyzer({nowarn_function, yeccpars2_397_/1}). +-compile({nowarn_unused_function, yeccpars2_397_/1}). +-file("src/future_elixir_parser.yrl", 341). +yeccpars2_397_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op([], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_400_/1}). +-dialyzer({nowarn_function, yeccpars2_400_/1}). +-compile({nowarn_unused_function, yeccpars2_400_/1}). +-file("src/future_elixir_parser.yrl", 343). +yeccpars2_400_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_op([{'when', meta_from_token(___2), [___3]}], ___4) + end | __Stack]. + +-compile({inline,yeccpars2_401_/1}). +-dialyzer({nowarn_function, yeccpars2_401_/1}). +-compile({nowarn_unused_function, yeccpars2_401_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_401_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_402_/1}). +-dialyzer({nowarn_function, yeccpars2_402_/1}). +-compile({nowarn_unused_function, yeccpars2_402_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_402_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_403_/1}). +-dialyzer({nowarn_function, yeccpars2_403_/1}). +-compile({nowarn_unused_function, yeccpars2_403_/1}). +-file("src/future_elixir_parser.yrl", 515). +yeccpars2_403_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___2] + end | __Stack]. + +-compile({inline,yeccpars2_404_/1}). +-dialyzer({nowarn_function, yeccpars2_404_/1}). +-compile({nowarn_unused_function, yeccpars2_404_/1}). +-file("src/future_elixir_parser.yrl", 516). +yeccpars2_404_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_405_/1}). +-dialyzer({nowarn_function, yeccpars2_405_/1}). +-compile({nowarn_unused_function, yeccpars2_405_/1}). +-file("src/future_elixir_parser.yrl", 335). +yeccpars2_405_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + annotate_eoe(___2, ___1) + end | __Stack]. + +-compile({inline,yeccpars2_406_/1}). +-dialyzer({nowarn_function, yeccpars2_406_/1}). +-compile({nowarn_unused_function, yeccpars2_406_/1}). +-file("src/future_elixir_parser.yrl", 332). +yeccpars2_406_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | annotate_eoe(___2, ___1)] + end | __Stack]. + +-compile({inline,yeccpars2_407_/1}). +-dialyzer({nowarn_function, yeccpars2_407_/1}). +-compile({nowarn_unused_function, yeccpars2_407_/1}). +-file("src/future_elixir_parser.yrl", 264). +yeccpars2_407_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_408_/1}). +-dialyzer({nowarn_function, yeccpars2_408_/1}). +-compile({nowarn_unused_function, yeccpars2_408_/1}). +-file("src/future_elixir_parser.yrl", 352). +yeccpars2_408_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_409_/1}). +-dialyzer({nowarn_function, yeccpars2_409_/1}). +-compile({nowarn_unused_function, yeccpars2_409_/1}). +-file("src/future_elixir_parser.yrl", 347). +yeccpars2_409_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op(unwrap_splice(___1), ___2) + end | __Stack]. + +-compile({inline,yeccpars2_412_/1}). +-dialyzer({nowarn_function, yeccpars2_412_/1}). +-compile({nowarn_unused_function, yeccpars2_412_/1}). +-file("src/future_elixir_parser.yrl", 349). +yeccpars2_412_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_op([{'when', meta_from_token(___2), unwrap_splice(___1) ++ [___3]}], ___4) + end | __Stack]. + +-compile({inline,yeccpars2_413_/1}). +-dialyzer({nowarn_function, yeccpars2_413_/1}). +-compile({nowarn_unused_function, yeccpars2_413_/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_413_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_414_/1}). +-dialyzer({nowarn_function, yeccpars2_414_/1}). +-compile({nowarn_unused_function, yeccpars2_414_/1}). +-file("src/future_elixir_parser.yrl", 242). +yeccpars2_414_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_415_/1}). +-dialyzer({nowarn_function, yeccpars2_415_/1}). +-compile({nowarn_unused_function, yeccpars2_415_/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_415_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_416_/1}). +-dialyzer({nowarn_function, yeccpars2_416_/1}). +-compile({nowarn_unused_function, yeccpars2_416_/1}). +-file("src/future_elixir_parser.yrl", 161). +yeccpars2_416_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_417_/1}). +-dialyzer({nowarn_function, yeccpars2_417_/1}). +-compile({nowarn_unused_function, yeccpars2_417_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_417_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_418_/1}). +-dialyzer({nowarn_function, yeccpars2_418_/1}). +-compile({nowarn_unused_function, yeccpars2_418_/1}). +-file("src/future_elixir_parser.yrl", 561). +yeccpars2_418_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + [{___3, ___4} | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_419_/1}). +-dialyzer({nowarn_function, yeccpars2_419_/1}). +-compile({nowarn_unused_function, yeccpars2_419_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_419_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_420_/1}). +-dialyzer({nowarn_function, yeccpars2_420_/1}). +-compile({nowarn_unused_function, yeccpars2_420_/1}). +-file("src/future_elixir_parser.yrl", 560). +yeccpars2_420_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + [{___1, ___2}] + end | __Stack]. + +-compile({inline,yeccpars2_421_/1}). +-dialyzer({nowarn_function, yeccpars2_421_/1}). +-compile({nowarn_unused_function, yeccpars2_421_/1}). +-file("src/future_elixir_parser.yrl", 199). +yeccpars2_421_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_422_/1}). +-dialyzer({nowarn_function, yeccpars2_422_/1}). +-compile({nowarn_unused_function, yeccpars2_422_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_422_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_423_/1}). +-dialyzer({nowarn_function, yeccpars2_423_/1}). +-compile({nowarn_unused_function, yeccpars2_423_/1}). +-file("src/future_elixir_parser.yrl", 209). +yeccpars2_423_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_424_/1}). +-dialyzer({nowarn_function, yeccpars2_424_/1}). +-compile({nowarn_unused_function, yeccpars2_424_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_424_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_425_/1}). +-dialyzer({nowarn_function, yeccpars2_425_/1}). +-compile({nowarn_unused_function, yeccpars2_425_/1}). +-file("src/future_elixir_parser.yrl", 208). +yeccpars2_425_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_426_/1}). +-dialyzer({nowarn_function, yeccpars2_426_/1}). +-compile({nowarn_unused_function, yeccpars2_426_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_426_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_427_/1}). +-dialyzer({nowarn_function, yeccpars2_427_/1}). +-compile({nowarn_unused_function, yeccpars2_427_/1}). +-file("src/future_elixir_parser.yrl", 198). +yeccpars2_427_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_428_/1}). +-dialyzer({nowarn_function, yeccpars2_428_/1}). +-compile({nowarn_unused_function, yeccpars2_428_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_428_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_429_/1}). +-dialyzer({nowarn_function, yeccpars2_429_/1}). +-compile({nowarn_unused_function, yeccpars2_429_/1}). +-file("src/future_elixir_parser.yrl", 200). +yeccpars2_429_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_430_/1}). +-dialyzer({nowarn_function, yeccpars2_430_/1}). +-compile({nowarn_unused_function, yeccpars2_430_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_430_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_431_/1}). +-dialyzer({nowarn_function, yeccpars2_431_/1}). +-compile({nowarn_unused_function, yeccpars2_431_/1}). +-file("src/future_elixir_parser.yrl", 207). +yeccpars2_431_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_432_/1}). +-dialyzer({nowarn_function, yeccpars2_432_/1}). +-compile({nowarn_unused_function, yeccpars2_432_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_432_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_433_/1}). +-dialyzer({nowarn_function, yeccpars2_433_/1}). +-compile({nowarn_unused_function, yeccpars2_433_/1}). +-file("src/future_elixir_parser.yrl", 212). +yeccpars2_433_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_434_/1}). +-dialyzer({nowarn_function, yeccpars2_434_/1}). +-compile({nowarn_unused_function, yeccpars2_434_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_434_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_435_/1}). +-dialyzer({nowarn_function, yeccpars2_435_/1}). +-compile({nowarn_unused_function, yeccpars2_435_/1}). +-file("src/future_elixir_parser.yrl", 201). +yeccpars2_435_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_436_/1}). +-dialyzer({nowarn_function, yeccpars2_436_/1}). +-compile({nowarn_unused_function, yeccpars2_436_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_436_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_437_/1}). +-dialyzer({nowarn_function, yeccpars2_437_/1}). +-compile({nowarn_unused_function, yeccpars2_437_/1}). +-file("src/future_elixir_parser.yrl", 203). +yeccpars2_437_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_438_/1}). +-dialyzer({nowarn_function, yeccpars2_438_/1}). +-compile({nowarn_unused_function, yeccpars2_438_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_438_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_439_/1}). +-dialyzer({nowarn_function, yeccpars2_439_/1}). +-compile({nowarn_unused_function, yeccpars2_439_/1}). +-file("src/future_elixir_parser.yrl", 214). +yeccpars2_439_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_440_/1}). +-dialyzer({nowarn_function, yeccpars2_440_/1}). +-compile({nowarn_unused_function, yeccpars2_440_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_440_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_441_/1}). +-dialyzer({nowarn_function, yeccpars2_441_/1}). +-compile({nowarn_unused_function, yeccpars2_441_/1}). +-file("src/future_elixir_parser.yrl", 204). +yeccpars2_441_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_442_/1}). +-dialyzer({nowarn_function, yeccpars2_442_/1}). +-compile({nowarn_unused_function, yeccpars2_442_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_442_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_443_/1}). +-dialyzer({nowarn_function, yeccpars2_443_/1}). +-compile({nowarn_unused_function, yeccpars2_443_/1}). +-file("src/future_elixir_parser.yrl", 210). +yeccpars2_443_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_444_/1}). +-dialyzer({nowarn_function, yeccpars2_444_/1}). +-compile({nowarn_unused_function, yeccpars2_444_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_444_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_445_/1}). +-dialyzer({nowarn_function, yeccpars2_445_/1}). +-compile({nowarn_unused_function, yeccpars2_445_/1}). +-file("src/future_elixir_parser.yrl", 211). +yeccpars2_445_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_446_/1}). +-dialyzer({nowarn_function, yeccpars2_446_/1}). +-compile({nowarn_unused_function, yeccpars2_446_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_446_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_447_/1}). +-dialyzer({nowarn_function, yeccpars2_447_/1}). +-compile({nowarn_unused_function, yeccpars2_447_/1}). +-file("src/future_elixir_parser.yrl", 205). +yeccpars2_447_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_448_/1}). +-dialyzer({nowarn_function, yeccpars2_448_/1}). +-compile({nowarn_unused_function, yeccpars2_448_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_448_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_449_/1}). +-dialyzer({nowarn_function, yeccpars2_449_/1}). +-compile({nowarn_unused_function, yeccpars2_449_/1}). +-file("src/future_elixir_parser.yrl", 392). +yeccpars2_449_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_450_/1}). +-dialyzer({nowarn_function, yeccpars2_450_/1}). +-compile({nowarn_unused_function, yeccpars2_450_/1}). +-file("src/future_elixir_parser.yrl", 397). +yeccpars2_450_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_451_/1}). +-dialyzer({nowarn_function, yeccpars2_451_/1}). +-compile({nowarn_unused_function, yeccpars2_451_/1}). +-file("src/future_elixir_parser.yrl", 262). +yeccpars2_451_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, number_value(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_452_/1}). +-dialyzer({nowarn_function, yeccpars2_452_/1}). +-compile({nowarn_unused_function, yeccpars2_452_/1}). +-file("src/future_elixir_parser.yrl", 400). +yeccpars2_452_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_453_/1}). +-dialyzer({nowarn_function, yeccpars2_453_/1}). +-compile({nowarn_unused_function, yeccpars2_453_/1}). +-file("src/future_elixir_parser.yrl", 373). +yeccpars2_453_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_454_/1}). +-dialyzer({nowarn_function, yeccpars2_454_/1}). +-compile({nowarn_unused_function, yeccpars2_454_/1}). +-file("src/future_elixir_parser.yrl", 378). +yeccpars2_454_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_455_/1}). +-dialyzer({nowarn_function, yeccpars2_455_/1}). +-compile({nowarn_unused_function, yeccpars2_455_/1}). +-file("src/future_elixir_parser.yrl", 366). +yeccpars2_455_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_456_/1}). +-dialyzer({nowarn_function, yeccpars2_456_/1}). +-compile({nowarn_unused_function, yeccpars2_456_/1}). +-file("src/future_elixir_parser.yrl", 629). +yeccpars2_456_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_,'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_,'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_458_eol/1}). +-dialyzer({nowarn_function, yeccpars2_458_eol/1}). +-compile({nowarn_unused_function, yeccpars2_458_eol/1}). +-file("src/future_elixir_parser.yrl", 602). +yeccpars2_458_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_{'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_{'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_{'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_{'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_}'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_}'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_458_/1}). +-dialyzer({nowarn_function, yeccpars2_458_/1}). +-compile({nowarn_unused_function, yeccpars2_458_/1}). +-file("src/future_elixir_parser.yrl", 148). +yeccpars2_458_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_462_/1}). +-dialyzer({nowarn_function, yeccpars2_462_/1}). +-compile({nowarn_unused_function, yeccpars2_462_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_462_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_463_/1}). +-dialyzer({nowarn_function, yeccpars2_463_/1}). +-compile({nowarn_unused_function, yeccpars2_463_/1}). +-file("src/future_elixir_parser.yrl", 605). +yeccpars2_463_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_464_/1}). +-dialyzer({nowarn_function, yeccpars2_464_/1}). +-compile({nowarn_unused_function, yeccpars2_464_/1}). +-file("src/future_elixir_parser.yrl", 603). +yeccpars2_464_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_466_/1}). +-dialyzer({nowarn_function, yeccpars2_466_/1}). +-compile({nowarn_unused_function, yeccpars2_466_/1}). +-file("src/future_elixir_parser.yrl", 643). +yeccpars2_466_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {'%', meta_from_token(___1), [___2, ___3]} + end | __Stack]. + +-compile({inline,yeccpars2_468_/1}). +-dialyzer({nowarn_function, yeccpars2_468_/1}). +-compile({nowarn_unused_function, yeccpars2_468_/1}). +-file("src/future_elixir_parser.yrl", 644). +yeccpars2_468_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + {'%', meta_from_token(___1), [___2, ___4]} + end | __Stack]. + +-compile({inline,yeccpars2_472_/1}). +-dialyzer({nowarn_function, yeccpars2_472_/1}). +-compile({nowarn_unused_function, yeccpars2_472_/1}). +-file("src/future_elixir_parser.yrl", 636). +yeccpars2_472_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_map(___1, element(1, ___2), element(2, ___2)) + end | __Stack]. + +-compile({inline,yeccpars2_473_/1}). +-dialyzer({nowarn_function, yeccpars2_473_/1}). +-compile({nowarn_unused_function, yeccpars2_473_/1}). +-file("src/future_elixir_parser.yrl", 614). +yeccpars2_473_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_476_/1}). +-dialyzer({nowarn_function, yeccpars2_476_/1}). +-compile({nowarn_unused_function, yeccpars2_476_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_476_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_481_/1}). +-dialyzer({nowarn_function, yeccpars2_481_/1}). +-compile({nowarn_unused_function, yeccpars2_481_/1}). +-file("src/future_elixir_parser.yrl", 622). +yeccpars2_481_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_482_/1}). +-dialyzer({nowarn_function, yeccpars2_482_/1}). +-compile({nowarn_unused_function, yeccpars2_482_/1}). +-file("src/future_elixir_parser.yrl", 625). +yeccpars2_482_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_484_/1}). +-dialyzer({nowarn_function, yeccpars2_484_/1}). +-compile({nowarn_unused_function, yeccpars2_484_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_484_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_485_/1}). +-dialyzer({nowarn_function, yeccpars2_485_/1}). +-compile({nowarn_unused_function, yeccpars2_485_/1}). +-file("src/future_elixir_parser.yrl", 635). +yeccpars2_485_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_map(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_488_/1}). +-dialyzer({nowarn_function, yeccpars2_488_/1}). +-compile({nowarn_unused_function, yeccpars2_488_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_488_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_489_/1}). +-dialyzer({nowarn_function, yeccpars2_489_/1}). +-compile({nowarn_unused_function, yeccpars2_489_/1}). +-file("src/future_elixir_parser.yrl", 162). +yeccpars2_489_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_490_/1}). +-dialyzer({nowarn_function, yeccpars2_490_/1}). +-compile({nowarn_unused_function, yeccpars2_490_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_490_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_491_/1}). +-dialyzer({nowarn_function, yeccpars2_491_/1}). +-compile({nowarn_unused_function, yeccpars2_491_/1}). +-file("src/future_elixir_parser.yrl", 155). +yeccpars2_491_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_492_/1}). +-dialyzer({nowarn_function, yeccpars2_492_/1}). +-compile({nowarn_unused_function, yeccpars2_492_/1}). +-file("src/future_elixir_parser.yrl", 161). +yeccpars2_492_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_493_/1}). +-dialyzer({nowarn_function, yeccpars2_493_/1}). +-compile({nowarn_unused_function, yeccpars2_493_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_493_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_494_/1}). +-dialyzer({nowarn_function, yeccpars2_494_/1}). +-compile({nowarn_unused_function, yeccpars2_494_/1}). +-file("src/future_elixir_parser.yrl", 604). +yeccpars2_494_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_495_/1}). +-dialyzer({nowarn_function, yeccpars2_495_/1}). +-compile({nowarn_unused_function, yeccpars2_495_/1}). +-file("src/future_elixir_parser.yrl", 154). +yeccpars2_495_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_496_/1}). +-dialyzer({nowarn_function, yeccpars2_496_/1}). +-compile({nowarn_unused_function, yeccpars2_496_/1}). +-file("src/future_elixir_parser.yrl", 632). +yeccpars2_496_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_497_/1}). +-dialyzer({nowarn_function, yeccpars2_497_/1}). +-compile({nowarn_unused_function, yeccpars2_497_/1}). +-file("src/future_elixir_parser.yrl", 626). +yeccpars2_497_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_501_/1}). +-dialyzer({nowarn_function, yeccpars2_501_/1}). +-compile({nowarn_unused_function, yeccpars2_501_/1}). +-file("src/future_elixir_parser.yrl", 623). +yeccpars2_501_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_502_/1}). +-dialyzer({nowarn_function, yeccpars2_502_/1}). +-compile({nowarn_unused_function, yeccpars2_502_/1}). +-file("src/future_elixir_parser.yrl", 633). +yeccpars2_502_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + {reverse(___1, ___3), ___4} + end | __Stack]. + +-compile({inline,yeccpars2_522_/1}). +-dialyzer({nowarn_function, yeccpars2_522_/1}). +-compile({nowarn_unused_function, yeccpars2_522_/1}). +-file("src/future_elixir_parser.yrl", 607). +yeccpars2_522_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_523_/1}). +-dialyzer({nowarn_function, yeccpars2_523_/1}). +-compile({nowarn_unused_function, yeccpars2_523_/1}). +-file("src/future_elixir_parser.yrl", 608). +yeccpars2_523_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_525_/1}). +-dialyzer({nowarn_function, yeccpars2_525_/1}). +-compile({nowarn_unused_function, yeccpars2_525_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_525_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_527_/1}). +-dialyzer({nowarn_function, yeccpars2_527_/1}). +-compile({nowarn_unused_function, yeccpars2_527_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_527_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_528_/1}). +-dialyzer({nowarn_function, yeccpars2_528_/1}). +-compile({nowarn_unused_function, yeccpars2_528_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_528_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_529_/1}). +-dialyzer({nowarn_function, yeccpars2_529_/1}). +-compile({nowarn_unused_function, yeccpars2_529_/1}). +-file("src/future_elixir_parser.yrl", 612). +yeccpars2_529_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_530_/1}). +-dialyzer({nowarn_function, yeccpars2_530_/1}). +-compile({nowarn_unused_function, yeccpars2_530_/1}). +-file("src/future_elixir_parser.yrl", 610). +yeccpars2_530_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_531_/1}). +-dialyzer({nowarn_function, yeccpars2_531_/1}). +-compile({nowarn_unused_function, yeccpars2_531_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_531_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_532_/1}). +-dialyzer({nowarn_function, yeccpars2_532_/1}). +-compile({nowarn_unused_function, yeccpars2_532_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_532_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_533_/1}). +-dialyzer({nowarn_function, yeccpars2_533_/1}). +-compile({nowarn_unused_function, yeccpars2_533_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_533_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_534_/1}). +-dialyzer({nowarn_function, yeccpars2_534_/1}). +-compile({nowarn_unused_function, yeccpars2_534_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_534_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_535_/1}). +-dialyzer({nowarn_function, yeccpars2_535_/1}). +-compile({nowarn_unused_function, yeccpars2_535_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_535_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_536_/1}). +-dialyzer({nowarn_function, yeccpars2_536_/1}). +-compile({nowarn_unused_function, yeccpars2_536_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_536_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_537_/1}). +-dialyzer({nowarn_function, yeccpars2_537_/1}). +-compile({nowarn_unused_function, yeccpars2_537_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_537_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_538_/1}). +-dialyzer({nowarn_function, yeccpars2_538_/1}). +-compile({nowarn_unused_function, yeccpars2_538_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_538_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_539_/1}). +-dialyzer({nowarn_function, yeccpars2_539_/1}). +-compile({nowarn_unused_function, yeccpars2_539_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_539_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_540_/1}). +-dialyzer({nowarn_function, yeccpars2_540_/1}). +-compile({nowarn_unused_function, yeccpars2_540_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_540_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_541_/1}). +-dialyzer({nowarn_function, yeccpars2_541_/1}). +-compile({nowarn_unused_function, yeccpars2_541_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_541_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_542_/1}). +-dialyzer({nowarn_function, yeccpars2_542_/1}). +-compile({nowarn_unused_function, yeccpars2_542_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_542_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_543_/1}). +-dialyzer({nowarn_function, yeccpars2_543_/1}). +-compile({nowarn_unused_function, yeccpars2_543_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_543_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_544_/1}). +-dialyzer({nowarn_function, yeccpars2_544_/1}). +-compile({nowarn_unused_function, yeccpars2_544_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_544_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_545_/1}). +-dialyzer({nowarn_function, yeccpars2_545_/1}). +-compile({nowarn_unused_function, yeccpars2_545_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_545_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_546_/1}). +-dialyzer({nowarn_function, yeccpars2_546_/1}). +-compile({nowarn_unused_function, yeccpars2_546_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_546_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_548_/1}). +-dialyzer({nowarn_function, yeccpars2_548_/1}). +-compile({nowarn_unused_function, yeccpars2_548_/1}). +-file("src/future_elixir_parser.yrl", 611). +yeccpars2_548_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_549_/1}). +-dialyzer({nowarn_function, yeccpars2_549_/1}). +-compile({nowarn_unused_function, yeccpars2_549_/1}). +-file("src/future_elixir_parser.yrl", 613). +yeccpars2_549_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_550_/1}). +-dialyzer({nowarn_function, yeccpars2_550_/1}). +-compile({nowarn_unused_function, yeccpars2_550_/1}). +-file("src/future_elixir_parser.yrl", 637). +yeccpars2_550_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___3, []) + end | __Stack]. + +-compile({inline,yeccpars2_552_/1}). +-dialyzer({nowarn_function, yeccpars2_552_/1}). +-compile({nowarn_unused_function, yeccpars2_552_/1}). +-file("src/future_elixir_parser.yrl", 639). +yeccpars2_552_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, element(2, ___4), element(1, ___4)) + end | __Stack]. + +-compile({inline,yeccpars2_553_/1}). +-dialyzer({nowarn_function, yeccpars2_553_/1}). +-compile({nowarn_unused_function, yeccpars2_553_/1}). +-file("src/future_elixir_parser.yrl", 638). +yeccpars2_553_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___4, []) + end | __Stack]. + +-compile({inline,yeccpars2_554_/1}). +-dialyzer({nowarn_function, yeccpars2_554_/1}). +-compile({nowarn_unused_function, yeccpars2_554_/1}). +-file("src/future_elixir_parser.yrl", 640). +yeccpars2_554_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___3, []) + end | __Stack]. + +-compile({inline,yeccpars2_555_/1}). +-dialyzer({nowarn_function, yeccpars2_555_/1}). +-compile({nowarn_unused_function, yeccpars2_555_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_555_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_556_/1}). +-dialyzer({nowarn_function, yeccpars2_556_/1}). +-compile({nowarn_unused_function, yeccpars2_556_/1}). +-file("src/future_elixir_parser.yrl", 156). +yeccpars2_556_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_$end'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_)'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_,'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_.'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_.'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_.'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_.'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_;'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_>>'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_]'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_and_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_557_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_557_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_comp_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_concat_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_dot_call_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_dot_call_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_dot_call_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_dot_call_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_dual_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_end/1}). +-dialyzer({nowarn_function, yeccpars2_557_end/1}). +-compile({nowarn_unused_function, yeccpars2_557_end/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_eol/1}). +-dialyzer({nowarn_function, yeccpars2_557_eol/1}). +-compile({nowarn_unused_function, yeccpars2_557_eol/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_in_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_match_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_mult_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_or_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_power_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_range_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_rel_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_stab_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_type_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_when_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_xor_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_}'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_/1}). +-dialyzer({nowarn_function, yeccpars2_557_/1}). +-compile({nowarn_unused_function, yeccpars2_557_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_557_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_560_/1}). +-dialyzer({nowarn_function, yeccpars2_560_/1}). +-compile({nowarn_unused_function, yeccpars2_560_/1}). +-file("src/future_elixir_parser.yrl", 172). +yeccpars2_560_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_561_/1}). +-dialyzer({nowarn_function, yeccpars2_561_/1}). +-compile({nowarn_unused_function, yeccpars2_561_/1}). +-file("src/future_elixir_parser.yrl", 325). +yeccpars2_561_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_562_/1}). +-dialyzer({nowarn_function, yeccpars2_562_/1}). +-compile({nowarn_unused_function, yeccpars2_562_/1}). +-file("src/future_elixir_parser.yrl", 326). +yeccpars2_562_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_565_/1}). +-dialyzer({nowarn_function, yeccpars2_565_/1}). +-compile({nowarn_unused_function, yeccpars2_565_/1}). +-file("src/future_elixir_parser.yrl", 360). +yeccpars2_565_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-file("src/future_elixir_parser.erl", 31857). +-compile({inline,yeccpars2_566_/1}). +-dialyzer({nowarn_function, yeccpars2_566_/1}). +-compile({nowarn_unused_function, yeccpars2_566_/1}). +-file("src/future_elixir_parser.yrl", 357). +yeccpars2_566_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + {handle_literal(?exprs(___1), ___1), {'__block__', [], []}} + end | __Stack]. + +-compile({inline,yeccpars2_567_/1}). +-dialyzer({nowarn_function, yeccpars2_567_/1}). +-compile({nowarn_unused_function, yeccpars2_567_/1}). +-file("src/future_elixir_parser.yrl", 328). +yeccpars2_567_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_568_/1}). +-dialyzer({nowarn_function, yeccpars2_568_/1}). +-compile({nowarn_unused_function, yeccpars2_568_/1}). +-file("src/future_elixir_parser.yrl", 309). +yeccpars2_568_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___2), [[{handle_literal(do, ___1), {'__block__', [], []}}]]} + end | __Stack]. + +-compile({inline,yeccpars2_569_/1}). +-dialyzer({nowarn_function, yeccpars2_569_/1}). +-compile({nowarn_unused_function, yeccpars2_569_/1}). +-file("src/future_elixir_parser.yrl", 329). +yeccpars2_569_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 31900). +-compile({inline,yeccpars2_570_/1}). +-dialyzer({nowarn_function, yeccpars2_570_/1}). +-compile({nowarn_unused_function, yeccpars2_570_/1}). +-file("src/future_elixir_parser.yrl", 355). +yeccpars2_570_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {handle_literal(?exprs(___1), ___1), build_stab(___2)} + end | __Stack]. + +-compile({inline,yeccpars2_571_/1}). +-dialyzer({nowarn_function, yeccpars2_571_/1}). +-compile({nowarn_unused_function, yeccpars2_571_/1}). +-file("src/future_elixir_parser.yrl", 361). +yeccpars2_571_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + [___1 | ___2] + end | __Stack]. + +-compile({inline,yeccpars2_572_/1}). +-dialyzer({nowarn_function, yeccpars2_572_/1}). +-compile({nowarn_unused_function, yeccpars2_572_/1}). +-file("src/future_elixir_parser.yrl", 313). +yeccpars2_572_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___3), [[{handle_literal(do, ___1), {'__block__', [], []}} | ___2]]} + end | __Stack]. + +-compile({inline,yeccpars2_574_/1}). +-dialyzer({nowarn_function, yeccpars2_574_/1}). +-compile({nowarn_unused_function, yeccpars2_574_/1}). +-file("src/future_elixir_parser.yrl", 311). +yeccpars2_574_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___3), [[{handle_literal(do, ___1), build_stab(___2)}]]} + end | __Stack]. + +-compile({inline,yeccpars2_575_/1}). +-dialyzer({nowarn_function, yeccpars2_575_/1}). +-compile({nowarn_unused_function, yeccpars2_575_/1}). +-file("src/future_elixir_parser.yrl", 315). +yeccpars2_575_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___4), [[{handle_literal(do, ___1), build_stab(___2)} | ___3]]} + end | __Stack]. + +-compile({inline,'yeccpars2_576_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_$end'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_)'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_,'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_.'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_.'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_.'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_.'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_;'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_>>'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_]'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_and_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_576_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_576_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_comp_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_concat_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_dot_call_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_dot_call_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_dot_call_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_dot_call_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_dual_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_end/1}). +-dialyzer({nowarn_function, yeccpars2_576_end/1}). +-compile({nowarn_unused_function, yeccpars2_576_end/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_eol/1}). +-dialyzer({nowarn_function, yeccpars2_576_eol/1}). +-compile({nowarn_unused_function, yeccpars2_576_eol/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_in_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_match_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_mult_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_or_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_power_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_range_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_rel_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_stab_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_type_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_when_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_xor_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_}'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_/1}). +-dialyzer({nowarn_function, yeccpars2_576_/1}). +-compile({nowarn_unused_function, yeccpars2_576_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_576_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_578_/1}). +-dialyzer({nowarn_function, yeccpars2_578_/1}). +-compile({nowarn_unused_function, yeccpars2_578_/1}). +-file("src/future_elixir_parser.yrl", 171). +yeccpars2_578_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_579_/1}). +-dialyzer({nowarn_function, yeccpars2_579_/1}). +-compile({nowarn_unused_function, yeccpars2_579_/1}). +-file("src/future_elixir_parser.yrl", 631). +yeccpars2_579_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_581_/1}). +-dialyzer({nowarn_function, yeccpars2_581_/1}). +-compile({nowarn_unused_function, yeccpars2_581_/1}). +-file("src/future_elixir_parser.yrl", 212). +yeccpars2_581_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_582_/1}). +-dialyzer({nowarn_function, yeccpars2_582_/1}). +-compile({nowarn_unused_function, yeccpars2_582_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_582_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_583_/1}). +-dialyzer({nowarn_function, yeccpars2_583_/1}). +-compile({nowarn_unused_function, yeccpars2_583_/1}). +-file("src/future_elixir_parser.yrl", 619). +yeccpars2_583_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_584_/1}). +-dialyzer({nowarn_function, yeccpars2_584_/1}). +-compile({nowarn_unused_function, yeccpars2_584_/1}). +-file("src/future_elixir_parser.yrl", 616). +yeccpars2_584_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, [___3]} + end | __Stack]. + +-compile({inline,yeccpars2_586_/1}). +-dialyzer({nowarn_function, yeccpars2_586_/1}). +-compile({nowarn_unused_function, yeccpars2_586_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_586_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_587_/1}). +-dialyzer({nowarn_function, yeccpars2_587_/1}). +-compile({nowarn_unused_function, yeccpars2_587_/1}). +-file("src/future_elixir_parser.yrl", 620). +yeccpars2_587_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_588_/1}). +-dialyzer({nowarn_function, yeccpars2_588_/1}). +-compile({nowarn_unused_function, yeccpars2_588_/1}). +-file("src/future_elixir_parser.yrl", 617). +yeccpars2_588_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, [___3]} + end | __Stack]. + +-compile({inline,yeccpars2_589_/1}). +-dialyzer({nowarn_function, yeccpars2_589_/1}). +-compile({nowarn_unused_function, yeccpars2_589_/1}). +-file("src/future_elixir_parser.yrl", 300). +yeccpars2_589_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_access(___1, meta_with_from_brackets(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_590_/1}). +-dialyzer({nowarn_function, yeccpars2_590_/1}). +-compile({nowarn_unused_function, yeccpars2_590_/1}). +-file("src/future_elixir_parser.yrl", 163). +yeccpars2_590_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_591_/1}). +-dialyzer({nowarn_function, yeccpars2_591_/1}). +-compile({nowarn_unused_function, yeccpars2_591_/1}). +-file("src/future_elixir_parser.yrl", 299). +yeccpars2_591_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_access(build_identifier(___1), meta_with_from_brackets(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_592_/1}). +-dialyzer({nowarn_function, yeccpars2_592_/1}). +-compile({nowarn_unused_function, yeccpars2_592_/1}). +-file("src/future_elixir_parser.yrl", 291). +yeccpars2_592_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_593_/1}). +-dialyzer({nowarn_function, yeccpars2_593_/1}). +-compile({nowarn_unused_function, yeccpars2_593_/1}). +-file("src/future_elixir_parser.yrl", 168). +yeccpars2_593_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_594_/1}). +-dialyzer({nowarn_function, yeccpars2_594_/1}). +-compile({nowarn_unused_function, yeccpars2_594_/1}). +-file("src/future_elixir_parser.yrl", 292). +yeccpars2_594_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_595_/1}). +-dialyzer({nowarn_function, yeccpars2_595_/1}). +-compile({nowarn_unused_function, yeccpars2_595_/1}). +-file("src/future_elixir_parser.yrl", 169). +yeccpars2_595_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_596_/1}). +-dialyzer({nowarn_function, yeccpars2_596_/1}). +-compile({nowarn_unused_function, yeccpars2_596_/1}). +-file("src/future_elixir_parser.yrl", 170). +yeccpars2_596_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, [], ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_597_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_$end'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_$end'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_)'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_,'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_,'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_;'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_>>'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_>>'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_]'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_]'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_and_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_and_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_arrow_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_assoc_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_597_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_597_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_comp_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_comp_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_concat_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_concat_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_dual_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_dual_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_end/1}). +-dialyzer({nowarn_function, yeccpars2_597_end/1}). +-compile({nowarn_unused_function, yeccpars2_597_end/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_eol/1}). +-dialyzer({nowarn_function, yeccpars2_597_eol/1}). +-compile({nowarn_unused_function, yeccpars2_597_eol/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_in_match_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_in_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_in_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_match_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_match_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_mult_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_mult_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_or_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_or_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_pipe_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_power_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_power_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_range_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_range_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_rel_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_rel_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_stab_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_stab_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_ternary_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_type_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_type_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_when_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_when_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_xor_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_xor_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_}'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_}'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_/1}). +-dialyzer({nowarn_function, yeccpars2_597_/1}). +-compile({nowarn_unused_function, yeccpars2_597_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_597_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_598_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_$end'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_)'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_,'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_;'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_>>'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_]'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_and_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_598_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_598_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_comp_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_concat_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_dual_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_end/1}). +-dialyzer({nowarn_function, yeccpars2_598_end/1}). +-compile({nowarn_unused_function, yeccpars2_598_end/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_eol/1}). +-dialyzer({nowarn_function, yeccpars2_598_eol/1}). +-compile({nowarn_unused_function, yeccpars2_598_eol/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_in_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_match_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_mult_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_or_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_power_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_range_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_rel_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_stab_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_type_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_when_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_xor_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_}'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_/1}). +-dialyzer({nowarn_function, yeccpars2_598_/1}). +-compile({nowarn_unused_function, yeccpars2_598_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_598_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_599_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_$end'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_)'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_,'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_;'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_>>'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_]'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_and_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_599_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_599_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_comp_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_concat_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_dual_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_end/1}). +-dialyzer({nowarn_function, yeccpars2_599_end/1}). +-compile({nowarn_unused_function, yeccpars2_599_end/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_eol/1}). +-dialyzer({nowarn_function, yeccpars2_599_eol/1}). +-compile({nowarn_unused_function, yeccpars2_599_eol/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_in_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_match_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_mult_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_or_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_power_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_range_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_rel_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_stab_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_type_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_when_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_xor_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_}'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_/1}). +-dialyzer({nowarn_function, yeccpars2_599_/1}). +-compile({nowarn_unused_function, yeccpars2_599_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_599_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_600_/1}). +-dialyzer({nowarn_function, yeccpars2_600_/1}). +-compile({nowarn_unused_function, yeccpars2_600_/1}). +-file("src/future_elixir_parser.yrl", 90). +yeccpars2_600_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_601_/1}). +-dialyzer({nowarn_function, yeccpars2_601_/1}). +-compile({nowarn_unused_function, yeccpars2_601_/1}). +-file("src/future_elixir_parser.yrl", 92). +yeccpars2_601_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(annotate_eoe(___3, ___2))) + end | __Stack]. + +-compile({inline,yeccpars2_602_/1}). +-dialyzer({nowarn_function, yeccpars2_602_/1}). +-compile({nowarn_unused_function, yeccpars2_602_/1}). +-file("src/future_elixir_parser.yrl", 97). +yeccpars2_602_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | annotate_eoe(___2, ___1)] + end | __Stack]. + +-compile({inline,yeccpars2_603_/1}). +-dialyzer({nowarn_function, yeccpars2_603_/1}). +-compile({nowarn_unused_function, yeccpars2_603_/1}). +-file("src/future_elixir_parser.yrl", 91). +yeccpars2_603_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(annotate_eoe(___2, ___1))) + end | __Stack]. + +-compile({inline,yeccpars2_605_/1}). +-dialyzer({nowarn_function, yeccpars2_605_/1}). +-compile({nowarn_unused_function, yeccpars2_605_/1}). +-file("src/future_elixir_parser.yrl", 263). +yeccpars2_605_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_fn(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_606_/1}). +-dialyzer({nowarn_function, yeccpars2_606_/1}). +-compile({nowarn_unused_function, yeccpars2_606_/1}). +-file("src/future_elixir_parser.yrl", 642). +yeccpars2_606_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + adjust_map_column(___2) + end | __Stack]. + +-compile({inline,yeccpars2_609_/1}). +-dialyzer({nowarn_function, yeccpars2_609_/1}). +-compile({nowarn_unused_function, yeccpars2_609_/1}). +-file("src/future_elixir_parser.yrl", 596). +yeccpars2_609_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_bit(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_610_/1}). +-dialyzer({nowarn_function, yeccpars2_610_/1}). +-compile({nowarn_unused_function, yeccpars2_610_/1}). +-file("src/future_elixir_parser.yrl", 598). +yeccpars2_610_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_bit(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_611_/1}). +-dialyzer({nowarn_function, yeccpars2_611_/1}). +-compile({nowarn_unused_function, yeccpars2_611_/1}). +-file("src/future_elixir_parser.yrl", 379). +yeccpars2_611_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_613_/1}). +-dialyzer({nowarn_function, yeccpars2_613_/1}). +-compile({nowarn_unused_function, yeccpars2_613_/1}). +-file("src/future_elixir_parser.yrl", 380). +yeccpars2_613_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_614_/1}). +-dialyzer({nowarn_function, yeccpars2_614_/1}). +-compile({nowarn_unused_function, yeccpars2_614_/1}). +-file("src/future_elixir_parser.yrl", 597). +yeccpars2_614_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + bad_keyword(___1, bitstring) + end | __Stack]. + +-compile({inline,yeccpars2_616_/1}). +-dialyzer({nowarn_function, yeccpars2_616_/1}). +-compile({nowarn_unused_function, yeccpars2_616_/1}). +-file("src/future_elixir_parser.yrl", 580). +yeccpars2_616_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_617_/1}). +-dialyzer({nowarn_function, yeccpars2_617_/1}). +-compile({nowarn_unused_function, yeccpars2_617_/1}). +-file("src/future_elixir_parser.yrl", 581). +yeccpars2_617_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_618_/1}). +-dialyzer({nowarn_function, yeccpars2_618_/1}). +-compile({nowarn_unused_function, yeccpars2_618_/1}). +-file("src/future_elixir_parser.yrl", 585). +yeccpars2_618_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_list(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_619_/1}). +-dialyzer({nowarn_function, yeccpars2_619_/1}). +-compile({nowarn_unused_function, yeccpars2_619_/1}). +-file("src/future_elixir_parser.yrl", 582). +yeccpars2_619_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_620_/1}). +-dialyzer({nowarn_function, yeccpars2_620_/1}). +-compile({nowarn_unused_function, yeccpars2_620_/1}). +-file("src/future_elixir_parser.yrl", 583). +yeccpars2_620_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_621_/1}). +-dialyzer({nowarn_function, yeccpars2_621_/1}). +-compile({nowarn_unused_function, yeccpars2_621_/1}). +-file("src/future_elixir_parser.yrl", 586). +yeccpars2_621_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_list(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_624_/1}). +-dialyzer({nowarn_function, yeccpars2_624_/1}). +-compile({nowarn_unused_function, yeccpars2_624_/1}). +-file("src/future_elixir_parser.yrl", 590). +yeccpars2_624_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_tuple(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_625_/1}). +-dialyzer({nowarn_function, yeccpars2_625_/1}). +-compile({nowarn_unused_function, yeccpars2_625_/1}). +-file("src/future_elixir_parser.yrl", 592). +yeccpars2_625_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_tuple(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_626_/1}). +-dialyzer({nowarn_function, yeccpars2_626_/1}). +-compile({nowarn_unused_function, yeccpars2_626_/1}). +-file("src/future_elixir_parser.yrl", 591). +yeccpars2_626_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + bad_keyword(___1, tuple) + end | __Stack]. + + +-file("src/future_elixir_parser.yrl", 1285). diff --git a/forge/src/future_elixir_parser.yrl b/forge/src/future_elixir_parser.yrl new file mode 100644 index 00000000..804fcb3a --- /dev/null +++ b/forge/src/future_elixir_parser.yrl @@ -0,0 +1,1284 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_parser.yrl +Nonterminals + grammar expr_list + expr container_expr block_expr access_expr + no_parens_expr no_parens_zero_expr no_parens_one_expr no_parens_one_ambig_expr + bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr sub_matched_expr + unmatched_op_expr matched_op_expr no_parens_op_expr no_parens_many_expr + comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol capture_op_eol + dual_op_eol mult_op_eol power_op_eol concat_op_eol xor_op_eol pipe_op_eol + stab_op_eol arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol + type_op_eol rel_op_eol range_op_eol ternary_op_eol + open_paren close_paren empty_paren eoe + list list_args open_bracket close_bracket + tuple open_curly close_curly + bitstring open_bit close_bit + map map_op map_base_expr map_close map_args + assoc_op_eol assoc_expr assoc_base assoc assoc_update assoc_update_kw + container_args_base container_args + call_args_parens_expr call_args_parens_base call_args_parens parens_call + call_args_no_parens_one call_args_no_parens_ambig call_args_no_parens_expr + call_args_no_parens_comma_expr call_args_no_parens_all call_args_no_parens_many + call_args_no_parens_many_strict + stab stab_eoe stab_expr stab_op_eol_and_expr stab_parens_many + kw_eol kw_base kw_data kw_call call_args_no_parens_kw_expr call_args_no_parens_kw + dot_op dot_alias dot_bracket_identifier dot_call_identifier + dot_identifier dot_op_identifier dot_do_identifier dot_paren_identifier + do_block fn_eoe do_eoe block_eoe block_item block_list + . + +Terminals + identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier + paren_identifier do_identifier block_identifier op_identifier + fn 'end' alias + atom atom_quoted atom_safe atom_unsafe bin_string list_string sigil + bin_heredoc list_heredoc + comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op ellipsis_op + type_op dual_op mult_op power_op concat_op range_op xor_op pipe_op stab_op when_op + capture_int capture_op assoc_op rel_op ternary_op dot_call_op + 'true' 'false' 'nil' 'do' eol ';' ',' '.' + '(' ')' '[' ']' '{' '}' '<<' '>>' '%{}' '%' + int flt char + . + +Rootsymbol grammar. + +%% Two shift/reduce conflicts coming from call_args_parens and +%% one coming from empty_paren on stab. +Expect 3. + +%% Changes in ops and precedence should be reflected on: +%% +%% 1. lib/elixir/lib/code/identifier.ex +%% 2. lib/elixir/pages/operators.md +%% 3. lib/iex/lib/iex/evaluator.ex +%% +%% Note though the operator => in practice has lower precedence +%% than all others, its entry in the table is only to support the +%% %{user | foo => bar} syntax. + +Left 5 do. +Right 10 stab_op_eol. %% -> +Left 20 ','. +Left 40 in_match_op_eol. %% <-, \\ (allowed in matches along =) +Right 50 when_op_eol. %% when +Right 60 type_op_eol. %% :: +Right 70 pipe_op_eol. %% | +Right 80 assoc_op_eol. %% => +Nonassoc 90 capture_op_eol. %% & +Nonassoc 90 ellipsis_op. %% ... +Right 100 match_op_eol. %% = +Left 120 or_op_eol. %% ||, |||, or +Left 130 and_op_eol. %% &&, &&&, and +Left 140 comp_op_eol. %% ==, !=, =~, ===, !== +Left 150 rel_op_eol. %% <, >, <=, >= +Left 160 arrow_op_eol. %% |>, <<<, >>>, <<~, ~>>, <~, ~>, <~>, <|> +Left 170 in_op_eol. %% in, not in +Left 180 xor_op_eol. %% ^^^ +Right 190 ternary_op_eol. %% // +Right 200 concat_op_eol. %% ++, --, +++, ---, <> +Right 200 range_op_eol. %% .. +Left 210 dual_op_eol. %% +, - +Left 220 mult_op_eol. %% *, / +Left 230 power_op_eol. %% ** +Nonassoc 300 unary_op_eol. %% +, -, !, ^, not, ~~~ +Left 310 dot_call_op. +Left 310 dot_op. %% . +Nonassoc 320 at_op_eol. %% @ +Nonassoc 330 dot_identifier. + +%%% MAIN FLOW OF EXPRESSIONS + +grammar -> eoe : {'__block__', meta_from_token('$1'), []}. +grammar -> expr_list : build_block(reverse('$1')). +grammar -> eoe expr_list : build_block(reverse('$2')). +grammar -> expr_list eoe : build_block(reverse(annotate_eoe('$2', '$1'))). +grammar -> eoe expr_list eoe : build_block(reverse(annotate_eoe('$3', '$2'))). +grammar -> '$empty' : {'__block__', [], []}. + +% Note expressions are on reverse order +expr_list -> expr : ['$1']. +expr_list -> expr_list eoe expr : ['$3' | annotate_eoe('$2', '$1')]. + +expr -> matched_expr : '$1'. +expr -> no_parens_expr : '$1'. +expr -> unmatched_expr : '$1'. + +%% In Elixir we have three main call syntaxes: with parentheses, +%% without parentheses and with do blocks. They are represented +%% in the AST as matched, no_parens and unmatched. +%% +%% Calls without parentheses are further divided according to how +%% problematic they are: +%% +%% (a) no_parens_one: a call with one unproblematic argument +%% (for example, `f a` or `f g a` and similar) (includes unary operators) +%% +%% (b) no_parens_many: a call with several arguments (for example, `f a, b`) +%% +%% (c) no_parens_one_ambig: a call with one argument which is +%% itself a no_parens_many or no_parens_one_ambig (for example, `f g a, b`, +%% `f g h a, b` and similar) +%% +%% Note, in particular, that no_parens_one_ambig expressions are +%% ambiguous and are interpreted such that the outer function has +%% arity 1. For instance, `f g a, b` is interpreted as `f(g(a, b))` rather +%% than `f(g(a), b)`. Hence the name, no_parens_one_ambig. +%% +%% The distinction is required because we can't, for example, have +%% a function call with a do block as argument inside another do +%% block call, unless there are parentheses: +%% +%% if if true do true else false end do #=> invalid +%% if(if true do true else false end) do #=> valid +%% +%% Similarly, it is not possible to nest calls without parentheses +%% if their arity is more than 1: +%% +%% foo a, bar b, c #=> invalid +%% foo(a, bar b, c) #=> invalid +%% foo bar a, b #=> valid +%% foo a, bar(b, c) #=> valid +%% +%% So the different grammar rules need to take into account +%% if calls without parentheses are do blocks in particular +%% segments and act accordingly. +matched_expr -> matched_expr matched_op_expr : build_op('$1', '$2'). +matched_expr -> unary_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> at_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> capture_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> ellipsis_op matched_expr : build_unary_op('$1', '$2'). +matched_expr -> no_parens_one_expr : '$1'. +matched_expr -> sub_matched_expr : '$1'. + +unmatched_expr -> matched_expr unmatched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr matched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr unmatched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr no_parens_op_expr : warn_no_parens_after_do_op('$2'), build_op('$1', '$2'). +unmatched_expr -> unary_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> at_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> capture_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> ellipsis_op expr : build_unary_op('$1', '$2'). +unmatched_expr -> block_expr : '$1'. + +no_parens_expr -> matched_expr no_parens_op_expr : build_op('$1', '$2'). +no_parens_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> ellipsis_op no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> no_parens_one_ambig_expr : '$1'. +no_parens_expr -> no_parens_many_expr : '$1'. + +block_expr -> dot_call_identifier call_args_parens do_block : build_parens('$1', '$2', '$3'). +block_expr -> dot_call_identifier call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3', '$4'). +block_expr -> dot_do_identifier do_block : build_no_parens_do_block('$1', [], '$2'). +block_expr -> dot_op_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3'). +block_expr -> dot_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3'). + +matched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> dual_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> power_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> concat_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> range_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> ternary_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> xor_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}. + +%% We warn exclusively for |> and friends because they are used +%% in other languages with lower precedence than function application, +%% which can be the source of confusion. +matched_op_expr -> arrow_op_eol no_parens_one_expr : warn_pipe('$1', '$2'), {'$1', '$2'}. + +unmatched_op_expr -> match_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> dual_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> mult_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> power_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> concat_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> range_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> ternary_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> xor_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> and_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> or_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> in_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> in_match_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> type_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> when_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> pipe_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> comp_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> rel_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> arrow_op_eol unmatched_expr : {'$1', '$2'}. + +no_parens_op_expr -> match_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> dual_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> mult_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> power_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> concat_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> range_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> ternary_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> xor_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> and_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> or_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> in_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> in_match_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> type_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> pipe_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> comp_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> rel_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> arrow_op_eol no_parens_expr : warn_pipe('$1', '$2'), {'$1', '$2'}. + +%% Allow when (and only when) with keywords +no_parens_op_expr -> when_op_eol call_args_no_parens_kw : {'$1', '$2'}. + +no_parens_one_ambig_expr -> dot_op_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2'). +no_parens_one_ambig_expr -> dot_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2'). + +no_parens_many_expr -> dot_op_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2'). +no_parens_many_expr -> dot_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2'). + +no_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_no_parens('$1', '$2'). +no_parens_one_expr -> dot_identifier call_args_no_parens_one : build_no_parens('$1', '$2'). +no_parens_zero_expr -> dot_do_identifier : build_identifier('$1'). +no_parens_zero_expr -> dot_identifier : build_identifier('$1'). + +sub_matched_expr -> no_parens_zero_expr : '$1'. +sub_matched_expr -> range_op : build_nullary_op('$1'). +sub_matched_expr -> ellipsis_op : build_nullary_op('$1'). +sub_matched_expr -> access_expr : '$1'. +sub_matched_expr -> access_expr kw_identifier : error_invalid_kw_identifier('$2'). + +%% From this point on, we just have constructs that can be +%% used with the access syntax. Note that (dot_)identifier +%% is not included in this list simply because the tokenizer +%% marks identifiers followed by brackets as bracket_identifier. +access_expr -> bracket_at_expr : '$1'. +access_expr -> bracket_expr : '$1'. +access_expr -> capture_int int : build_unary_op('$1', number_value('$2')). +access_expr -> fn_eoe stab_eoe 'end' : build_fn('$1', '$2', '$3'). +access_expr -> open_paren stab_eoe ')' : build_paren_stab('$1', '$2', '$3'). +access_expr -> open_paren ';' stab_eoe ')' : build_paren_stab('$1', '$3', '$4'). +access_expr -> open_paren ';' close_paren : build_paren_stab('$1', [], '$3'). +access_expr -> empty_paren : warn_empty_paren('$1'), {'__block__', [], []}. +access_expr -> int : handle_number(number_value('$1'), '$1', ?exprs('$1')). +access_expr -> flt : handle_number(number_value('$1'), '$1', ?exprs('$1')). +access_expr -> char : handle_number(?exprs('$1'), '$1', number_value('$1')). +access_expr -> list : element(1, '$1'). +access_expr -> map : '$1'. +access_expr -> tuple : '$1'. +access_expr -> 'true' : handle_literal(?id('$1'), '$1'). +access_expr -> 'false' : handle_literal(?id('$1'), '$1'). +access_expr -> 'nil' : handle_literal(?id('$1'), '$1'). +access_expr -> bin_string : build_bin_string('$1', delimiter(<<$">>)). +access_expr -> list_string : build_list_string('$1', delimiter(<<$'>>)). +access_expr -> bin_heredoc : build_bin_heredoc('$1'). +access_expr -> list_heredoc : build_list_heredoc('$1'). +access_expr -> bitstring : '$1'. +access_expr -> sigil : build_sigil('$1'). +access_expr -> atom : handle_literal(?exprs('$1'), '$1'). +access_expr -> atom_quoted : handle_literal(?exprs('$1'), '$1', delimiter(<<$">>)). +access_expr -> atom_safe : build_quoted_atom('$1', true, delimiter(<<$">>)). +access_expr -> atom_unsafe : build_quoted_atom('$1', false, delimiter(<<$">>)). +access_expr -> dot_alias : '$1'. +access_expr -> parens_call : '$1'. + +%% Also used by maps and structs +parens_call -> dot_call_identifier call_args_parens : build_parens('$1', '$2', {[], []}). +parens_call -> dot_call_identifier call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3', {[], []}). + +bracket_arg -> open_bracket kw_data close_bracket : build_access_arg('$1', '$2', '$3'). +bracket_arg -> open_bracket container_expr close_bracket : build_access_arg('$1', '$2', '$3'). +bracket_arg -> open_bracket container_expr ',' close_bracket : build_access_arg('$1', '$2', '$4'). +bracket_arg -> open_bracket container_expr ',' container_args close_bracket : error_too_many_access_syntax('$3'). + +bracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1'), meta_with_from_brackets('$2')). +bracket_expr -> access_expr bracket_arg : build_access('$1', meta_with_from_brackets('$2')). + +bracket_at_expr -> at_op_eol dot_bracket_identifier bracket_arg : + build_access(build_unary_op('$1', build_identifier('$2')), meta_with_from_brackets('$3')). +bracket_at_expr -> at_op_eol access_expr bracket_arg : + build_access(build_unary_op('$1', '$2'), meta_with_from_brackets('$3')). + +%% Blocks + +do_block -> do_eoe 'end' : + {do_end_meta('$1', '$2'), [[{handle_literal(do, '$1'), {'__block__', [], []}}]]}. +do_block -> do_eoe stab_eoe 'end' : + {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), build_stab('$2')}]]}. +do_block -> do_eoe block_list 'end' : + {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), {'__block__', [], []}} | '$2']]}. +do_block -> do_eoe stab_eoe block_list 'end' : + {do_end_meta('$1', '$4'), [[{handle_literal(do, '$1'), build_stab('$2')} | '$3']]}. + +eoe -> eol : '$1'. +eoe -> ';' : '$1'. +eoe -> eol ';' : '$1'. + +fn_eoe -> 'fn' : '$1'. +fn_eoe -> 'fn' eoe : next_is_eol('$1', '$2'). + +do_eoe -> 'do' : '$1'. +do_eoe -> 'do' eoe : '$1'. + +block_eoe -> block_identifier : '$1'. +block_eoe -> block_identifier eoe : '$1'. + +stab -> stab_expr : ['$1']. +stab -> stab eoe stab_expr : ['$3' | annotate_eoe('$2', '$1')]. + +stab_eoe -> stab : '$1'. +stab_eoe -> stab eoe : annotate_eoe('$2', '$1'). + +stab_expr -> expr : + '$1'. +stab_expr -> stab_op_eol_and_expr : + build_op([], '$1'). +stab_expr -> empty_paren stab_op_eol_and_expr : + build_op([], '$2'). +stab_expr -> empty_paren when_op expr stab_op_eol_and_expr : + build_op([{'when', meta_from_token('$2'), ['$3']}], '$4'). +stab_expr -> call_args_no_parens_all stab_op_eol_and_expr : + build_op(unwrap_when(unwrap_splice('$1')), '$2'). +stab_expr -> stab_parens_many stab_op_eol_and_expr : + build_op(unwrap_splice('$1'), '$2'). +stab_expr -> stab_parens_many when_op expr stab_op_eol_and_expr : + build_op([{'when', meta_from_token('$2'), unwrap_splice('$1') ++ ['$3']}], '$4'). + +stab_op_eol_and_expr -> stab_op_eol expr : {'$1', '$2'}. +stab_op_eol_and_expr -> stab_op_eol : warn_empty_stab_clause('$1'), {'$1', handle_literal(nil, '$1')}. + +block_item -> block_eoe stab_eoe : + {handle_literal(?exprs('$1'), '$1'), build_stab('$2')}. +block_item -> block_eoe : + {handle_literal(?exprs('$1'), '$1'), {'__block__', [], []}}. + +block_list -> block_item : ['$1']. +block_list -> block_item block_list : ['$1' | '$2']. + +%% Helpers + +open_paren -> '(' : '$1'. +open_paren -> '(' eol : next_is_eol('$1', '$2'). +close_paren -> ')' : '$1'. +close_paren -> eol ')' : '$2'. + +empty_paren -> open_paren ')' : '$1'. + +open_bracket -> '[' : '$1'. +open_bracket -> '[' eol : next_is_eol('$1', '$2'). +close_bracket -> ']' : '$1'. +close_bracket -> eol ']' : '$2'. + +open_bit -> '<<' : '$1'. +open_bit -> '<<' eol : next_is_eol('$1', '$2'). +close_bit -> '>>' : '$1'. +close_bit -> eol '>>' : '$2'. + +open_curly -> '{' : '$1'. +open_curly -> '{' eol : next_is_eol('$1', '$2'). +close_curly -> '}' : '$1'. +close_curly -> eol '}' : '$2'. + +% Operators + +unary_op_eol -> unary_op : '$1'. +unary_op_eol -> unary_op eol : '$1'. +unary_op_eol -> dual_op : '$1'. +unary_op_eol -> dual_op eol : '$1'. +unary_op_eol -> ternary_op : '$1'. +unary_op_eol -> ternary_op eol : '$1'. + +capture_op_eol -> capture_op : '$1'. +capture_op_eol -> capture_op eol : '$1'. + +at_op_eol -> at_op : '$1'. +at_op_eol -> at_op eol : '$1'. + +match_op_eol -> match_op : '$1'. +match_op_eol -> match_op eol : next_is_eol('$1', '$2'). + +dual_op_eol -> dual_op : '$1'. +dual_op_eol -> dual_op eol : next_is_eol('$1', '$2'). + +mult_op_eol -> mult_op : '$1'. +mult_op_eol -> mult_op eol : next_is_eol('$1', '$2'). + +power_op_eol -> power_op : '$1'. +power_op_eol -> power_op eol : next_is_eol('$1', '$2'). + +concat_op_eol -> concat_op : '$1'. +concat_op_eol -> concat_op eol : next_is_eol('$1', '$2'). + +range_op_eol -> range_op : '$1'. +range_op_eol -> range_op eol : next_is_eol('$1', '$2'). + +ternary_op_eol -> ternary_op : '$1'. +ternary_op_eol -> ternary_op eol : next_is_eol('$1', '$2'). + +xor_op_eol -> xor_op : '$1'. +xor_op_eol -> xor_op eol : next_is_eol('$1', '$2'). + +pipe_op_eol -> pipe_op : '$1'. +pipe_op_eol -> pipe_op eol : next_is_eol('$1', '$2'). + +and_op_eol -> and_op : '$1'. +and_op_eol -> and_op eol : next_is_eol('$1', '$2'). + +or_op_eol -> or_op : '$1'. +or_op_eol -> or_op eol : next_is_eol('$1', '$2'). + +in_op_eol -> in_op : '$1'. +in_op_eol -> in_op eol : next_is_eol('$1', '$2'). + +in_match_op_eol -> in_match_op : '$1'. +in_match_op_eol -> in_match_op eol : next_is_eol('$1', '$2'). + +type_op_eol -> type_op : '$1'. +type_op_eol -> type_op eol : next_is_eol('$1', '$2'). + +when_op_eol -> when_op : '$1'. +when_op_eol -> when_op eol : next_is_eol('$1', '$2'). + +stab_op_eol -> stab_op : '$1'. +stab_op_eol -> stab_op eol : next_is_eol('$1', '$2'). + +comp_op_eol -> comp_op : '$1'. +comp_op_eol -> comp_op eol : next_is_eol('$1', '$2'). + +rel_op_eol -> rel_op : '$1'. +rel_op_eol -> rel_op eol : next_is_eol('$1', '$2'). + +arrow_op_eol -> arrow_op : '$1'. +arrow_op_eol -> arrow_op eol : next_is_eol('$1', '$2'). + +% Dot operator + +dot_op -> '.' : '$1'. +dot_op -> '.' eol : '$1'. + +dot_identifier -> identifier : '$1'. +dot_identifier -> matched_expr dot_op identifier : build_dot('$2', '$1', '$3'). + +dot_alias -> alias : build_alias('$1'). +dot_alias -> matched_expr dot_op alias : build_dot_alias('$2', '$1', '$3'). +dot_alias -> matched_expr dot_op open_curly '}' : build_dot_container('$2', '$1', [], []). +dot_alias -> matched_expr dot_op open_curly container_args close_curly : build_dot_container('$2', '$1', '$4', newlines_pair('$3', '$5')). + +dot_op_identifier -> op_identifier : '$1'. +dot_op_identifier -> matched_expr dot_op op_identifier : build_dot('$2', '$1', '$3'). + +dot_do_identifier -> do_identifier : '$1'. +dot_do_identifier -> matched_expr dot_op do_identifier : build_dot('$2', '$1', '$3'). + +dot_bracket_identifier -> bracket_identifier : '$1'. +dot_bracket_identifier -> matched_expr dot_op bracket_identifier : build_dot('$2', '$1', '$3'). + +dot_paren_identifier -> paren_identifier : '$1'. +dot_paren_identifier -> matched_expr dot_op paren_identifier : build_dot('$2', '$1', '$3'). + +dot_call_identifier -> dot_paren_identifier : '$1'. +dot_call_identifier -> matched_expr dot_call_op : {'.', meta_from_token('$2'), ['$1']}. % Fun/local calls + +% Function calls with no parentheses + +call_args_no_parens_expr -> matched_expr : '$1'. +call_args_no_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1'). + +call_args_no_parens_comma_expr -> matched_expr ',' call_args_no_parens_expr : ['$3', '$1']. +call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3' | '$1']. + +call_args_no_parens_all -> call_args_no_parens_one : '$1'. +call_args_no_parens_all -> call_args_no_parens_ambig : '$1'. +call_args_no_parens_all -> call_args_no_parens_many : '$1'. + +call_args_no_parens_one -> call_args_no_parens_kw : ['$1']. +call_args_no_parens_one -> matched_expr : ['$1']. + +%% This is the only no parens ambiguity where we don't +%% raise nor warn: "parent_call nested_call 1, 2, 3" +%% always assumes that all arguments are nested. +call_args_no_parens_ambig -> no_parens_expr : ['$1']. + +call_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw : ['$1', '$3']. +call_args_no_parens_many -> call_args_no_parens_comma_expr : reverse('$1'). +call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3' | '$1']). + +call_args_no_parens_many_strict -> call_args_no_parens_many : '$1'. +call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : error_no_parens_strict('$1'). +call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : error_no_parens_strict('$1'). + +stab_parens_many -> open_paren call_args_no_parens_kw close_paren : ['$2']. +stab_parens_many -> open_paren call_args_no_parens_many close_paren : '$2'. + +% Containers + +container_expr -> matched_expr : '$1'. +container_expr -> unmatched_expr : '$1'. +container_expr -> no_parens_expr : error_no_parens_container_strict('$1'). + +container_args_base -> container_expr : ['$1']. +container_args_base -> container_args_base ',' container_expr : ['$3' | '$1']. + +container_args -> container_args_base : reverse('$1'). +container_args -> container_args_base ',' : reverse('$1'). +container_args -> container_args_base ',' kw_data : reverse(['$3' | '$1']). + +% Function calls with parentheses + +call_args_parens_expr -> matched_expr : '$1'. +call_args_parens_expr -> unmatched_expr : '$1'. +call_args_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1'). + +call_args_parens_base -> call_args_parens_expr : ['$1']. +call_args_parens_base -> call_args_parens_base ',' call_args_parens_expr : ['$3' | '$1']. + +call_args_parens -> open_paren ')' : + {newlines_pair('$1', '$2'), []}. +call_args_parens -> open_paren no_parens_expr close_paren : + {newlines_pair('$1', '$3'), ['$2']}. +call_args_parens -> open_paren kw_call close_paren : + {newlines_pair('$1', '$3'), ['$2']}. +call_args_parens -> open_paren call_args_parens_base close_paren : + {newlines_pair('$1', '$3'), reverse('$2')}. +call_args_parens -> open_paren call_args_parens_base ',' kw_call close_paren : + {newlines_pair('$1', '$5'), reverse(['$4' | '$2'])}. + +% KV + +kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', [{format, keyword}]). +kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', [{format, keyword}]). +kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, [{format, keyword}]). +kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, [{format, keyword}]). +kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, [{format, keyword}]). +kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, [{format, keyword}]). + +kw_base -> kw_eol container_expr : [{'$1', '$2'}]. +kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1']. + +kw_call -> kw_base : reverse('$1'). +kw_call -> kw_base ',' : warn_trailing_comma('$2'), reverse('$1'). +kw_call -> kw_base ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', '$1', '$3'). + +kw_data -> kw_base : reverse('$1'). +kw_data -> kw_base ',' : reverse('$1'). +kw_data -> kw_base ',' matched_expr : maybe_bad_keyword_data_follow_up('$2', '$1', '$3'). + +call_args_no_parens_kw_expr -> kw_eol matched_expr : {'$1', '$2'}. +call_args_no_parens_kw_expr -> kw_eol no_parens_expr : warn_nested_no_parens_keyword('$1', '$2'), {'$1', '$2'}. + +call_args_no_parens_kw -> call_args_no_parens_kw_expr : ['$1']. +call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1' | '$3']. +call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', ['$1'], '$3'). + +% Lists + +list_args -> kw_data : '$1'. +list_args -> container_args_base : reverse('$1'). +list_args -> container_args_base ',' : reverse('$1'). +list_args -> container_args_base ',' kw_data : reverse('$1', '$3'). + +list -> open_bracket ']' : build_list('$1', [], '$2'). +list -> open_bracket list_args close_bracket : build_list('$1', '$2', '$3'). + +% Tuple + +tuple -> open_curly '}' : build_tuple('$1', [], '$2'). +tuple -> open_curly kw_data '}' : bad_keyword('$1', tuple). +tuple -> open_curly container_args close_curly : build_tuple('$1', '$2', '$3'). + +% Bitstrings + +bitstring -> open_bit '>>' : build_bit('$1', [], '$2'). +bitstring -> open_bit kw_data '>>' : bad_keyword('$1', bitstring). +bitstring -> open_bit container_args close_bit : build_bit('$1', '$2', '$3'). + +% Map and structs + +map_base_expr -> sub_matched_expr : '$1'. +map_base_expr -> at_op_eol map_base_expr : build_unary_op('$1', '$2'). +map_base_expr -> unary_op_eol map_base_expr : build_unary_op('$1', '$2'). +map_base_expr -> ellipsis_op map_base_expr : build_unary_op('$1', '$2'). + +assoc_op_eol -> assoc_op : '$1'. +assoc_op_eol -> assoc_op eol : '$1'. + +assoc_expr -> matched_expr assoc_op_eol matched_expr : {'$1', '$3'}. +assoc_expr -> unmatched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}. +assoc_expr -> matched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}. +assoc_expr -> unmatched_expr assoc_op_eol matched_expr : {'$1', '$3'}. +assoc_expr -> map_base_expr : '$1'. + +assoc_update -> matched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}. +assoc_update -> unmatched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}. + +assoc_update_kw -> matched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}. +assoc_update_kw -> unmatched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}. + +assoc_base -> assoc_expr : ['$1']. +assoc_base -> assoc_base ',' assoc_expr : ['$3' | '$1']. + +assoc -> assoc_base : reverse('$1'). +assoc -> assoc_base ',' : reverse('$1'). + +map_op -> '%{}' : '$1'. +map_op -> '%{}' eol : '$1'. + +map_close -> kw_data close_curly : {'$1', '$2'}. +map_close -> assoc close_curly : {'$1', '$2'}. +map_close -> assoc_base ',' kw_data close_curly : {reverse('$1', '$3'), '$4'}. + +map_args -> open_curly '}' : build_map('$1', [], '$2'). +map_args -> open_curly map_close : build_map('$1', element(1, '$2'), element(2, '$2')). +map_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', '$3', []). +map_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', '$4', []). +map_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', element(2, '$4'), element(1, '$4')). +map_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', '$3', []). + +map -> map_op map_args : adjust_map_column('$2'). +map -> '%' map_base_expr map_args : {'%', meta_from_token('$1'), ['$2', '$3']}. +map -> '%' map_base_expr eol map_args : {'%', meta_from_token('$1'), ['$2', '$4']}. + +Erlang code. + +-define(columns(), get(elixir_parser_columns)). +-define(token_metadata(), get(elixir_token_metadata)). + +-define(id(Token), element(1, Token)). +-define(location(Token), element(2, Token)). +-define(exprs(Token), element(3, Token)). +-define(meta(Node), element(2, Node)). +-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')). + +-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}). +-import(lists, [reverse/1, reverse/2]). + +meta_from_token(Token) -> + meta_from_location(?location(Token)). + +meta_from_location({Line, Column, _}) -> + case ?columns() of + true -> [{line, Line}, {column, Column}]; + false -> [{line, Line}] + end. + +do_end_meta(Do, End) -> + case ?token_metadata() of + true -> + [{do, meta_from_location(?location(Do))}, {'end', meta_from_location(?location(End))}]; + false -> + [] + end. + +meta_from_token_with_closing(Begin, End) -> + case ?token_metadata() of + true -> + [{closing, meta_from_location(?location(End))} | meta_from_token(Begin)]; + false -> + meta_from_token(Begin) + end. + +append_non_empty(Left, []) -> Left; +append_non_empty(Left, Right) -> Left ++ Right. + +%% Handle metadata in literals + +handle_literal(Literal, Token) -> + handle_literal(Literal, Token, []). + +handle_literal(Literal, Token, ExtraMeta) -> + case get(elixir_literal_encoder) of + false -> + Literal; + + Fun -> + Meta = ExtraMeta ++ meta_from_token(Token), + case Fun(Literal, Meta) of + {ok, EncodedLiteral} -> + EncodedLiteral; + {error, Reason} -> + return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [": "], "literal") + end + end. + +handle_number(Number, Token, Original) -> + case ?token_metadata() of + true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]); + false -> handle_literal(Number, Token, []) + end. + +number_value({_, {_, _, Value}, _}) -> + Value. + +%% Operators + +build_op(Left, {Op, Right}) -> + build_op(Left, Op, Right). + +build_op(AST, {_Kind, Location, '//'}, Right) -> + case AST of + {'..', Meta, [Left, Middle]} -> + {'..//', Meta, [Left, Middle, Right]}; + + _ -> + return_error(Location, "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: ", "'//'") + end; + +build_op({UOp, _, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) -> + %% TODO: Remove "not left in right" rearrangement on v2.0 + warn({Line, Column}, "\"not expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead"), + Meta = meta_from_location(Location), + {UOp, Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, 'not in'}, Right) -> + Meta = meta_from_location(Location), + {'not', Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, Op}, Right) -> + {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}. + +build_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) -> + {Outer, Inner} = + case ?columns() of + true -> {[{column, Column+1}], [{column, Column}]}; + false -> {[], []} + end, + {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]}; + +build_unary_op({_Kind, Location, Op}, Expr) -> + {Op, meta_from_location(Location), [Expr]}. + +build_nullary_op({_Kind, Location, Op}) -> + {Op, meta_from_location(Location), []}. + +build_list(Left, Args, Right) -> + {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}. + +build_tuple(Left, [Arg1, Arg2], Right) -> + handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right)); +build_tuple(Left, Args, Right) -> + {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_bit(Left, Args, Right) -> + {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map(Left, Args, Right) -> + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) -> + Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)), + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}. + +adjust_map_column(Map) -> + case ?columns() of + true -> + {'%{}', Meta, Pairs} = Map, + UpdatedMeta = [{Key, if Key =:= column -> Value - 1; true -> Value end} || + {Key, Value} <- Meta], + {'%{}', UpdatedMeta, Pairs}; + false -> + Map + end. + +%% Blocks + +build_block(Exprs) -> build_block(Exprs, []). + +build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) -> + {'__block__', Meta, Exprs}; +build_block([Expr], _Meta) -> + Expr; +build_block(Exprs, Meta) -> + {'__block__', Meta, Exprs}. + +%% Newlines + +newlines_pair(Left, Right) -> + case ?token_metadata() of + true -> + newlines(?location(Left), [{closing, meta_from_location(?location(Right))}]); + false -> + [] + end. + +newlines_op(Location) -> + case ?token_metadata() of + true -> newlines(Location, []); + false -> [] + end. + +next_is_eol(Token, {_, {_, _, Count}}) -> + {Line, Column, _} = ?location(Token), + setelement(2, Token, {Line, Column, Count}). + +newlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) -> + [{newlines, Count} | Meta]; +newlines(_, Meta) -> + Meta. + +annotate_eoe(Token, Stack) -> + case ?token_metadata() of + true -> + case {Token, Stack} of + {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) -> + [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest]; + + {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' -> + [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest]; + + _ -> + Stack + end; + false -> + Stack + end. + +end_of_expression({_, _, Count} = Location) when is_integer(Count) -> + [{newlines, Count} | meta_from_location(Location)]; +end_of_expression(Location) -> + meta_from_location(Location). + +%% Dots + +build_alias({'alias', Location, Alias}) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(Location)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Alias]}. + +build_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) -> + MetaWithExtra = + case ?token_metadata() of + true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)}); + false -> Meta + end, + {'__aliases__', MetaWithExtra, Left ++ [Right]}; +build_dot_alias(_Dot, Atom, Right) when is_atom(Atom) -> + error_bad_atom(Right); +build_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) -> + Meta = meta_from_token(Dot), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(SegmentLocation)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Expr, Right]}. + +build_dot_container(Dot, Left, Right, Extra) -> + Meta = meta_from_token(Dot), + {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}. + +build_dot(Dot, Left, {_, Location, _} = Right) -> + Meta = meta_from_token(Dot), + IdentifierLocation = meta_from_location(Location), + {'.', Meta, IdentifierLocation, [Left, extract_identifier(Right)]}. + +extract_identifier({Kind, _, Identifier}) when + Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier; + Kind == do_identifier; Kind == op_identifier -> + Identifier. + +%% Identifiers + +build_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) -> + Identifier = build_parens(Dot, Args1, {[], []}), + Meta = BlockMeta ++ Args2Meta ++ ?meta(Identifier), + {Identifier, Meta, append_non_empty(Args2, Block)}. + +build_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)), + {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens_do_block(Expr, Args, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block), + {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens(Expr, Args) -> + build_call(Expr, Args). + +build_identifier({'.', Meta, IdentifierLocation, DotArgs}) -> + {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierLocation], []}; + +build_identifier({'.', Meta, _} = Dot) -> + {Dot, [{no_parens, true} | Meta], []}; + +build_identifier({_, Location, Identifier}) -> + {Identifier, meta_from_location(Location), nil}. + +build_call({'.', Meta, IdentifierLocation, DotArgs}, Args) -> + {{'.', Meta, DotArgs}, IdentifierLocation, Args}; + +build_call({'.', Meta, _} = Dot, Args) -> + {Dot, Meta, Args}; + +build_call({op_identifier, Location, Identifier}, [Arg]) -> + {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]}; + +build_call({_, Location, Identifier}, Args) -> + {Identifier, meta_from_location(Location), Args}. + +%% Fn + +build_fn(Fn, Stab, End) -> + case check_stab(Stab, none) of + stab -> + Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End), + {fn, Meta, collect_stab(Stab, [], [])}; + block -> + return_error(?location(Fn), "expected anonymous functions to be defined with -> inside: ", "'fn'") + end. + +%% Access + +build_access_arg(Left, Args, Right) -> + {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}. + +build_access(Expr, {List, Meta}) -> + {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}. + +%% Interpolation aware + +build_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) -> + Meta = meta_from_location(Location), + MetaWithDelimiter = [{delimiter, Delimiter} | Meta], + MetaWithIndentation = meta_with_indentation(Meta, Indentation), + {Atom, + MetaWithDelimiter, + [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}. + +meta_with_indentation(Meta, nil) -> + Meta; +meta_with_indentation(Meta, Indentation) -> + [{indentation, Indentation} | Meta]. + +meta_with_from_brackets({List, Meta}) -> + {List, [{from_brackets, true} | Meta]}. + +build_bin_heredoc({bin_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$", $", $">>}, {indentation, Indentation}]; + false -> [] + end, + build_bin_string({bin_string, Location, Args}, ExtraMeta). + +build_list_heredoc({list_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}]; + false -> [] + end, + build_list_string({list_string, Location, Args}, ExtraMeta). + +build_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(H, Token, ExtraMeta); +build_bin_string({bin_string, Location, Args}, ExtraMeta) -> + Meta = + case ?token_metadata() of + true -> ExtraMeta ++ meta_from_location(Location); + false -> meta_from_location(Location) + end, + {'<<>>', Meta, string_parts(Args)}. + +build_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(elixir_utils:characters_to_list(H), Token, ExtraMeta); +build_list_string({list_string, Location, Args}, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}. + +build_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) -> + Op = binary_to_atom_op(Safe), + handle_literal(erlang:Op(H, utf8), Token, ExtraMeta); +build_quoted_atom({_, Location, Args}, Safe, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}. + +binary_to_atom_op(true) -> binary_to_existing_atom; +binary_to_atom_op(false) -> binary_to_atom. + +charlist_parts(Parts) -> + [charlist_part(Part) || Part <- Parts]. +charlist_part(Binary) when is_binary(Binary) -> + Binary; +charlist_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}. + +string_parts(Parts) -> + [string_part(Part) || Part <- Parts]. +string_part(Binary) when is_binary(Binary) -> + Binary; +string_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}. + +string_tokens_parse(Tokens) -> + case parse(Tokens) of + {ok, Forms} -> Forms; + {error, _} = Error -> throw(Error) + end. + +delimiter(Delimiter) -> + case ?token_metadata() of + true -> [{delimiter, Delimiter}]; + false -> [] + end. + +%% Keywords + +check_stab([{'->', _, [_, _]}], _) -> stab; +check_stab([], none) -> block; +check_stab([_], none) -> block; +check_stab([_], Meta) -> error_invalid_stab(Meta); +check_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta); +check_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta). + +build_stab(Stab) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab)); + stab -> collect_stab(Stab, [], []) + end. + +build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) -> + {'__block__', [], Exprs}; +build_paren_stab(Before, Stab, After) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After)); + stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After)) + end. + +collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) -> + Stab = {'->', Meta, [Left, build_block([Right | Exprs])]}, + collect_stab(T, [], [Stab | Stabs]); + +collect_stab([H | T], Exprs, Stabs) -> + collect_stab(T, [H | Exprs], Stabs); + +collect_stab([], [], Stabs) -> + Stabs. + +%% Every time the parser sees a (unquote_splicing()) +%% it assumes that a block is being spliced, wrapping +%% the splicing in a __block__. But in the stab clause, +%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such +%% case, we don't actually want the block, since it is +%% an arg style call. unwrap_splice unwraps the splice +%% from such blocks. +unwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) -> + Splice; +unwrap_splice(Other) -> + Other. + +unwrap_when(Args) -> + case elixir_utils:split_last(Args) of + {Start, {'when', Meta, [_, _] = End}} -> + [{'when', Meta, Start ++ End}]; + {_, _} -> + Args + end. + +%% Warnings and errors + +return_error({Line, Column, _}, ErrorMessage, ErrorToken) -> + return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]). + +%% We should prefer to use return_error as it includes +%% Line and Column but that's not always possible. +return_error_with_meta(Meta, ErrorMessage, ErrorToken) -> + return_error(Meta, [ErrorMessage, ErrorToken]). + +error_invalid_stab(MetaStab) -> + return_error_with_meta(MetaStab, + "unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. " + "Syntax error before: ", "'->'"). + +error_bad_atom(Token) -> + return_error(?location(Token), "atom cannot be followed by an alias. " + "If the '.' was meant to be part of the atom's name, " + "the atom name must be quoted. Syntax error before: ", "'.'"). + +bad_keyword(Token, Context) -> + return_error(?location(Token), + "unexpected keyword list inside " ++ atom_to_list(Context) ++ ". " + "Did you mean to write a map (using %{...}) or a list (using [...]) instead? " + "Syntax error after: ", "'{'"). + +maybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_call_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\n\n" + " function_call(1, some: :option, 2)\n\n" + "Instead, wrap the keyword in brackets:\n\n" + " function_call(1, [some: :option], 2)\n\n" + "Syntax error after: ", "','"). + +maybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_data_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\n\n" + " [some: :value, :another]\n" + " %{some: :value, another => value}\n\n" + "Instead, reorder it to be the last entry:\n\n" + " [:another, some: :value]\n" + " %{another => value, some: :value}\n\n" + "Syntax error after: ", "','"). + +error_no_parens_strict(Token) -> + return_error(?location(Token), "unexpected parentheses. If you are making a " + "function call, do not insert spaces between the function name and the " + "opening parentheses. Syntax error before: ", "'('"). + +error_no_parens_many_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n" + "This error happens when you have nested function calls without parentheses. " + "For example:\n\n" + " parent_call a, nested_call b, c, d\n\n" + "In the example above, we don't know if the parameters \"c\" and \"d\" apply " + "to the function \"parent_call\" or \"nested_call\". You can solve this by " + "explicitly adding parentheses:\n\n" + " parent_call a, nested_call(b, c, d)\n\n" + "Or by adding commas (in case a nested call is not intended):\n\n" + " parent_call a, nested_call, b, c, d\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_no_parens_container_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n" + "This error may happen when you forget a comma in a list or other container:\n\n" + " [a, b c, d]\n\n" + "Or when you have ambiguous calls:\n\n" + " [function a, b, c]\n\n" + "In the example above, we don't know if the values \"b\" and \"c\" " + "belongs to the list or the function \"function\". You can solve this by explicitly " + "adding parentheses:\n\n" + " [one, function(a, b, c)]\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_too_many_access_syntax(Comma) -> + return_error(?location(Comma), "too many arguments when accessing a value. " + "The value[key] notation in Elixir expects either a single argument or a keyword list. " + "The following examples are allowed:\n\n" + " value[one]\n" + " value[one: 1, two: 2]\n" + " value[[one, two, three]]\n\n" + "These are invalid:\n\n" + " value[1, 2, 3]\n" + " value[one, two, three]\n\n" + "Syntax error after: ", "','"). + +error_invalid_kw_identifier({_, Location, do}) -> + return_error(Location, elixir_tokenizer:invalid_do_error("unexpected keyword: "), "do:"); +error_invalid_kw_identifier({_, Location, KW}) -> + return_error(Location, "syntax error before: ", "'" ++ atom_to_list(KW) ++ ":'"). + +%% TODO: Make this an error on v2.0 +warn_trailing_comma({',', {Line, Column, _}}) -> + warn({Line, Column}, "trailing commas are not allowed inside function/macro call arguments"). + +%% TODO: Make this an error on v2.0 +warn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) -> + warn( + {Line, Column}, + io_lib:format( + "parentheses are required when piping into a function call. For example:\n\n" + " foo 1 ~ts bar 2 ~ts baz 3\n\n" + "is ambiguous and should be written as\n\n" + " foo(1) ~ts bar(2) ~ts baz(3)\n\n" + "Ambiguous pipe found at:", + [Op, Op, Op, Op] + ) + ); +warn_pipe(_Token, _) -> + ok. + +%% TODO: Make this an error on v2.0 +warn_no_parens_after_do_op({{_Type, Location, Op}, _}) -> + {Line, _, _} = Location, + + warn( + Line, + "missing parentheses on expression following operator \"" ++ atom_to_list(Op) ++ "\", " + "you must add parentheses to avoid ambiguities" + ). + +%% TODO: Make this an error on v2.0 +warn_nested_no_parens_keyword(Key, Value) when is_atom(Key) -> + {line, Line} = lists:keyfind(line, 1, ?meta(Value)), + warn( + Line, + "missing parentheses for expression following \"" ++ atom_to_list(Key) ++ ":\" keyword. " + "Parentheses are required to solve ambiguity inside keywords.\n\n" + "This error happens when you have function calls without parentheses inside keywords. " + "For example:\n\n" + " function(arg, one: nested_call a, b, c)\n" + " function(arg, one: if expr, do: :this, else: :that)\n\n" + "In the examples above, we don't know if the arguments \"b\" and \"c\" apply " + "to the function \"function\" or \"nested_call\". Or if the keywords \"do\" and " + "\"else\" apply to the function \"function\" or \"if\". You can solve this by " + "explicitly adding parentheses:\n\n" + " function(arg, one: if(expr, do: :this, else: :that))\n" + " function(arg, one: nested_call(a, b, c))\n\n" + "Ambiguity found at:" + ); + +% Key might not be an atom when using literal_encoder, we just skip the warning +warn_nested_no_parens_keyword(_Key, _Value) -> + ok. + +warn_empty_paren({_, {Line, Column, _}}) -> + warn( + {Line, Column}, + "invalid expression (). " + "If you want to invoke or define a function, make sure there are " + "no spaces between the function name and its arguments. If you wanted " + "to pass an empty block or code, pass a value instead, such as a nil or an atom" + ). + +warn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) -> + warn( + {Line, Column}, + "an expression is always required on the right side of ->. " + "Please provide a value after ->" + ). + +warn(LineColumn, Message) -> + case get(elixir_parser_warning_file) of + nil -> ok; + File -> future_elixir_errors:erl_warn(LineColumn, File, Message) + end. diff --git a/forge/src/future_elixir_tokenizer.erl b/forge/src/future_elixir_tokenizer.erl new file mode 100644 index 00000000..0ace9a69 --- /dev/null +++ b/forge/src/future_elixir_tokenizer.erl @@ -0,0 +1,1827 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_tokenizer.erl +%% I changed module name and includes +-module(future_elixir_tokenizer). +-include("future_elixir.hrl"). +-include("future_elixir_tokenizer.hrl"). +-export([tokenize/1, tokenize/3, tokenize/4, invalid_do_error/1, terminator/1]). + +-define(at_op(T), + T =:= $@). + +-define(capture_op(T), + T =:= $&). + +-define(unary_op(T), + T =:= $!; + T =:= $^). + +-define(range_op(T1, T2), + T1 =:= $., T2 =:= $.). + +-define(concat_op(T1, T2), + T1 =:= $+, T2 =:= $+; + T1 =:= $-, T2 =:= $-; + T1 =:= $<, T2 =:= $>). + +-define(concat_op3(T1, T2, T3), + T1 =:= $+, T2 =:= $+, T3 =:= $+; + T1 =:= $-, T2 =:= $-, T3 =:= $-). + +-define(power_op(T1, T2), + T1 =:= $*, T2 =:= $*). + +-define(mult_op(T), + T =:= $* orelse T =:= $/). + +-define(dual_op(T), + T =:= $+ orelse T =:= $-). + +-define(arrow_op3(T1, T2, T3), + T1 =:= $<, T2 =:= $<, T3 =:= $<; + T1 =:= $>, T2 =:= $>, T3 =:= $>; + T1 =:= $~, T2 =:= $>, T3 =:= $>; + T1 =:= $<, T2 =:= $<, T3 =:= $~; + T1 =:= $<, T2 =:= $~, T3 =:= $>; + T1 =:= $<, T2 =:= $|, T3 =:= $>). + +-define(arrow_op(T1, T2), + T1 =:= $|, T2 =:= $>; + T1 =:= $~, T2 =:= $>; + T1 =:= $<, T2 =:= $~). + +-define(rel_op(T), + T =:= $<; + T =:= $>). + +-define(rel_op2(T1, T2), + T1 =:= $<, T2 =:= $=; + T1 =:= $>, T2 =:= $=). + +-define(comp_op2(T1, T2), + T1 =:= $=, T2 =:= $=; + T1 =:= $=, T2 =:= $~; + T1 =:= $!, T2 =:= $=). + +-define(comp_op3(T1, T2, T3), + T1 =:= $=, T2 =:= $=, T3 =:= $=; + T1 =:= $!, T2 =:= $=, T3 =:= $=). + +-define(ternary_op(T1, T2), + T1 =:= $/, T2 =:= $/). + +-define(and_op(T1, T2), + T1 =:= $&, T2 =:= $&). + +-define(or_op(T1, T2), + T1 =:= $|, T2 =:= $|). + +-define(and_op3(T1, T2, T3), + T1 =:= $&, T2 =:= $&, T3 =:= $&). + +-define(or_op3(T1, T2, T3), + T1 =:= $|, T2 =:= $|, T3 =:= $|). + +-define(match_op(T), + T =:= $=). + +-define(in_match_op(T1, T2), + T1 =:= $<, T2 =:= $-; + T1 =:= $\\, T2 =:= $\\). + +-define(stab_op(T1, T2), + T1 =:= $-, T2 =:= $>). + +-define(type_op(T1, T2), + T1 =:= $:, T2 =:= $:). + +-define(pipe_op(T), + T =:= $|). + +-define(ellipsis_op3(T1, T2, T3), + T1 =:= $., T2 =:= $., T3 =:= $.). + +%% Deprecated operators + +-define(unary_op3(T1, T2, T3), + T1 =:= $~, T2 =:= $~, T3 =:= $~). + +-define(xor_op3(T1, T2, T3), + T1 =:= $^, T2 =:= $^, T3 =:= $^). + +tokenize(String, Line, Column, #elixir_tokenizer{} = Scope) -> + tokenize(String, Line, Column, Scope, []); + +tokenize(String, Line, Column, Opts) -> + IdentifierTokenizer = elixir_config:identifier_tokenizer(), + + Scope = + lists:foldl(fun + ({check_terminators, false}, Acc) -> + Acc#elixir_tokenizer{terminators=none}; + ({cursor_completion, true}, Acc) -> + Acc#elixir_tokenizer{cursor_completion=prune_and_cursor}; + ({existing_atoms_only, ExistingAtomsOnly}, Acc) when is_boolean(ExistingAtomsOnly) -> + Acc#elixir_tokenizer{existing_atoms_only=ExistingAtomsOnly}; + ({static_atoms_encoder, StaticAtomsEncoder}, Acc) when is_function(StaticAtomsEncoder) -> + Acc#elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}; + ({preserve_comments, PreserveComments}, Acc) when is_function(PreserveComments) -> + Acc#elixir_tokenizer{preserve_comments=PreserveComments}; + ({unescape, Unescape}, Acc) when is_boolean(Unescape) -> + Acc#elixir_tokenizer{unescape=Unescape}; + (_, Acc) -> + Acc + end, #elixir_tokenizer{identifier_tokenizer=IdentifierTokenizer, column=Column}, Opts), + + tokenize(String, Line, Column, Scope, []). + +tokenize(String, Line, Opts) -> + tokenize(String, Line, 1, Opts). + +tokenize([], Line, Column, #elixir_tokenizer{cursor_completion=Cursor} = Scope, Tokens) when Cursor /= false -> + #elixir_tokenizer{ascii_identifiers_only=Ascii, terminators=Terminators, warnings=Warnings} = Scope, + + {CursorColumn, CursorTerminators, AccTokens} = + add_cursor(Line, Column, Cursor, Terminators, Tokens), + + AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings), + {AccTerminators, _AccColumn} = cursor_complete(Line, CursorColumn, CursorTerminators), + {ok, Line, CursorColumn, AllWarnings, AccTokens, AccTerminators}; + +tokenize([], EndLine, EndColumn, #elixir_tokenizer{terminators=[{Start, {StartLine, StartColumn, _}, _} | _]} = Scope, Tokens) -> + End = terminator(Start), + Hint = missing_terminator_hint(Start, End, Scope), + Message = "missing terminator: ~ts", + Formatted = io_lib:format(Message, [End]), + Meta = [ + {opening_delimiter, Start}, + {expected_delimiter, End}, + {line, StartLine}, + {column, StartColumn}, + {end_line, EndLine}, + {end_column, EndColumn} + ], + error({Meta, [Formatted, Hint], []}, [], Scope, Tokens); + +tokenize([], Line, Column, #elixir_tokenizer{} = Scope, Tokens) -> + #elixir_tokenizer{ascii_identifiers_only=Ascii, warnings=Warnings} = Scope, + AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings), + {ok, Line, Column, AllWarnings, Tokens, []}; + +% VC merge conflict + +tokenize(("<<<<<<<" ++ _) = Original, Line, 1, Scope, Tokens) -> + FirstLine = lists:takewhile(fun(C) -> C =/= $\n andalso C =/= $\r end, Original), + Reason = {?LOC(Line, 1), "found an unexpected version control marker, please resolve the conflicts: ", FirstLine}, + error(Reason, Original, Scope, Tokens); + +% Base integers + +tokenize([$0, $x, H | T], Line, Column, Scope, Tokens) when ?is_hex(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_hex(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +tokenize([$0, $b, H | T], Line, Column, Scope, Tokens) when ?is_bin(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_bin(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +tokenize([$0, $o, H | T], Line, Column, Scope, Tokens) when ?is_octal(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_octal(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +% Comments + +tokenize([$# | String], Line, Column, Scope, Tokens) -> + case tokenize_comment(String, [$#]) of + {error, Char} -> + error_comment(Char, [$# | String], Line, Column, Scope, Tokens); + {Rest, Comment} -> + preserve_comments(Line, Column, Tokens, Comment, Rest, Scope), + tokenize(Rest, Line, Column, Scope, reset_eol(Tokens)) + end; + +% Sigils + +tokenize([$~, H | _T] = Original, Line, Column, Scope, Tokens) when ?is_upcase(H) orelse ?is_downcase(H) -> + tokenize_sigil(Original, Line, Column, Scope, Tokens); + +% Char tokens + +% We tokenize char literals (?a) as {char, _, CharInt} instead of {number, _, +% CharInt}. This is exactly what Erlang does with Erlang char literals +% ($a). This means we'll have to adjust the error message for char literals in +% future_elixir_errors.erl as by default {char, _, _} tokens are "hijacked" by Erlang +% and printed with Erlang syntax ($a) in the parser's error messages. + +tokenize([$?, $\\, H | T], Line, Column, Scope, Tokens) -> + Char = future_elixir_interpolation:unescape_map(H), + + NewScope = if + H =:= Char, H =/= $\\ -> + case handle_char(Char) of + {Escape, Name} -> + Msg = io_lib:format("found ?\\ followed by code point 0x~.16B (~ts), please use ?~ts instead", + [Char, Name, Escape]), + prepend_warning(Line, Column, Msg, Scope); + + false when ?is_downcase(H); ?is_upcase(H) -> + Msg = io_lib:format("unknown escape sequence ?\\~tc, use ?~tc instead", [H, H]), + prepend_warning(Line, Column, Msg, Scope); + + false -> + Scope + end; + true -> + Scope + end, + + Token = {char, {Line, Column, [$?, $\\, H]}, Char}, + tokenize(T, Line, Column + 3, NewScope, [Token | Tokens]); + +tokenize([$?, Char | T], Line, Column, Scope, Tokens) -> + NewScope = case handle_char(Char) of + {Escape, Name} -> + Msg = io_lib:format("found ? followed by code point 0x~.16B (~ts), please use ?~ts instead", + [Char, Name, Escape]), + prepend_warning(Line, Column, Msg, Scope); + false -> + Scope + end, + Token = {char, {Line, Column, [$?, Char]}, Char}, + tokenize(T, Line, Column + 2, NewScope, [Token | Tokens]); + +% Heredocs + +tokenize("\"\"\"" ++ T, Line, Column, Scope, Tokens) -> + handle_heredocs(T, Line, Column, $", Scope, Tokens); + +%% TODO: Remove me in Elixir v2.0 +tokenize("'''" ++ T, Line, Column, Scope, Tokens) -> + NewScope = prepend_warning(Line, Column, "single-quoted string represent charlists. Use ~c''' if you indeed want a charlist or use \"\"\" instead", Scope), + handle_heredocs(T, Line, Column, $', NewScope, Tokens); + +% Strings + +tokenize([$" | T], Line, Column, Scope, Tokens) -> + handle_strings(T, Line, Column + 1, $", Scope, Tokens); + +%% TODO: Remove me in Elixir v2.0 +tokenize([$' | T], Line, Column, Scope, Tokens) -> + NewScope = prepend_warning(Line, Column, "single-quoted strings represent charlists. Use ~c\"\" if you indeed want a charlist or use \"\" instead", Scope), + handle_strings(T, Line, Column + 1, $', NewScope, Tokens); + +% Operator atoms + +tokenize(".:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '.'} | Tokens]); + +tokenize("<<>>:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '<<>>'} | Tokens]); +tokenize("%{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 4, Scope, [{kw_identifier, {Line, Column, nil}, '%{}'} | Tokens]); +tokenize("%:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '%'} | Tokens]); +tokenize("&:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '&'} | Tokens]); +tokenize("{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 3, Scope, [{kw_identifier, {Line, Column, nil}, '{}'} | Tokens]); +tokenize("..//:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '..//'} | Tokens]); + +tokenize(":<<>>" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '<<>>'} | Tokens]); +tokenize(":%{}" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 4, Scope, [{atom, {Line, Column, nil}, '%{}'} | Tokens]); +tokenize(":%" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 2, Scope, [{atom, {Line, Column, nil}, '%'} | Tokens]); +tokenize(":{}" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 3, Scope, [{atom, {Line, Column, nil}, '{}'} | Tokens]); +tokenize(":..//" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '..//'} | Tokens]); + +% ## Three Token Operators +tokenize([$:, T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when + ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3); + ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3); ?ellipsis_op3(T1, T2, T3) -> + Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2, T3])}, + tokenize(Rest, Line, Column + 4, Scope, [Token | Tokens]); + +% ## Two Token Operators + +tokenize([$:, $:, $: | Rest], Line, Column, Scope, Tokens) -> + Message = "atom ::: must be written between quotes, as in :\"::\", to avoid ambiguity", + NewScope = prepend_warning(Line, Column, Message, Scope), + Token = {atom, {Line, Column, nil}, '::'}, + tokenize(Rest, Line, Column + 3, NewScope, [Token | Tokens]); + +tokenize([$:, T1, T2 | Rest], Line, Column, Scope, Tokens) when + ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); + ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2); + ?stab_op(T1, T2); ?range_op(T1, T2) -> + Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2])}, + tokenize(Rest, Line, Column + 3, Scope, [Token | Tokens]); + +% ## Single Token Operators +tokenize([$:, T | Rest], Line, Column, Scope, Tokens) when + ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T); + ?rel_op(T); ?match_op(T); ?pipe_op(T); T =:= $. -> + Token = {atom, {Line, Column, nil}, list_to_atom([T])}, + tokenize(Rest, Line, Column + 2, Scope, [Token | Tokens]); + +% ## Stand-alone tokens + +tokenize("=>" ++ Rest, Line, Column, Scope, Tokens) -> + Token = {assoc_op, {Line, Column, previous_was_eol(Tokens)}, '=>'}, + tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens)); + +tokenize("..//" ++ Rest = String, Line, Column, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, '..//'}, + tokenize(Remaining, Line, Column + 4 + Extra, Scope, [Token | Tokens]); + {_, _} -> + unexpected_token(String, Line, Column, Scope, Tokens) + end; + +% ## Ternary operator + +% ## Three token operators +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?unary_op3(T1, T2, T3) -> + handle_unary_op(Rest, Line, Column, unary_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?ellipsis_op3(T1, T2, T3) -> + handle_unary_op(Rest, Line, Column, ellipsis_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?comp_op3(T1, T2, T3) -> + handle_op(Rest, Line, Column, comp_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?and_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, and_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?or_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, or_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?xor_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, xor_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?concat_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, concat_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?arrow_op3(T1, T2, T3) -> + handle_op(Rest, Line, Column, arrow_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +% ## Containers + punctuation tokens +tokenize([$, | Rest], Line, Column, Scope, Tokens) -> + Token = {',', {Line, Column, 0}}, + tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]); + +tokenize([$<, $< | Rest], Line, Column, Scope, Tokens) -> + Token = {'<<', {Line, Column, nil}}, + handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens); + +tokenize([$>, $> | Rest], Line, Column, Scope, Tokens) -> + Token = {'>>', {Line, Column, previous_was_eol(Tokens)}}, + handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens); + +tokenize([${ | Rest], Line, Column, Scope, [{'%', _} | _] = Tokens) -> + Message = + "unexpected space between % and {\n\n" + "If you want to define a map, write %{...}, with no spaces.\n" + "If you want to define a struct, write %StructName{...}.\n\n" + "Syntax error before: ", + error({?LOC(Line, Column), Message, [${]}, Rest, Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $(; T =:= ${; T =:= $[ -> + Token = {list_to_atom([T]), {Line, Column, nil}}, + handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $); T =:= $}; T =:= $] -> + Token = {list_to_atom([T]), {Line, Column, previous_was_eol(Tokens)}}, + handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens); + +% ## Two Token Operators +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?ternary_op(T1, T2) -> + Op = list_to_atom([T1, T2]), + Token = {ternary_op, {Line, Column, previous_was_eol(Tokens)}, Op}, + tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens)); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?power_op(T1, T2) -> + handle_op(Rest, Line, Column, power_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?range_op(T1, T2) -> + handle_op(Rest, Line, Column, range_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?concat_op(T1, T2) -> + handle_op(Rest, Line, Column, concat_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) -> + handle_op(Rest, Line, Column, arrow_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) -> + handle_op(Rest, Line, Column, comp_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) -> + handle_op(Rest, Line, Column, rel_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) -> + handle_op(Rest, Line, Column, and_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) -> + handle_op(Rest, Line, Column, or_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) -> + handle_op(Rest, Line, Column, in_match_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) -> + handle_op(Rest, Line, Column, type_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) -> + handle_op(Rest, Line, Column, stab_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +% ## Single Token Operators + +tokenize([$& | Rest], Line, Column, Scope, Tokens) -> + Kind = + case strip_horizontal_space(Rest, 0) of + {[Int | _], 0} when ?is_digit(Int) -> + capture_int; + + {[$/ | NewRest], _} -> + case strip_horizontal_space(NewRest, 0) of + {[$/ | _], _} -> capture_op; + {_, _} -> identifier + end; + + {_, _} -> + capture_op + end, + + Token = {Kind, {Line, Column, nil}, '&'}, + tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?at_op(T) -> + handle_unary_op(Rest, Line, Column, at_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?unary_op(T) -> + handle_unary_op(Rest, Line, Column, unary_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?rel_op(T) -> + handle_op(Rest, Line, Column, rel_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?dual_op(T) -> + handle_unary_op(Rest, Line, Column, dual_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?mult_op(T) -> + handle_op(Rest, Line, Column, mult_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?match_op(T) -> + handle_op(Rest, Line, Column, match_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) -> + handle_op(Rest, Line, Column, pipe_op, 1, list_to_atom([T]), Scope, Tokens); + +% Non-operator Atoms + +tokenize([$:, H | T] = Original, Line, Column, Scope, Tokens) when ?is_quote(H) -> + case future_elixir_interpolation:extract(Line, Column + 2, Scope, true, T, H) of + {NewLine, NewColumn, Parts, Rest, InterScope} -> + NewScope = case is_unnecessary_quote(Parts, InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted atom \"~ts\" but the quotes are not required. " + "Atoms made exclusively of ASCII letters, numbers, underscores, " + "beginning with a letter or underscore, and optionally ending with ! or ? " + "do not require quotes", + [hd(Parts)] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, [Part]} when is_binary(Part) -> + case unsafe_to_atom(Part, Line, Column, Scope) of + {ok, Atom} -> + Token = {atom_quoted, {Line, Column, nil}, Atom}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {ok, Unescaped} -> + Key = case Scope#elixir_tokenizer.existing_atoms_only of + true -> atom_safe; + false -> atom_unsafe + end, + Token = {Key, {Line, Column, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {error, Reason} -> + Message = " (for atom starting at line ~B)", + interpolation_error(Reason, Original, Scope, Tokens, Message, [Line], Line, Column + 1, [H], [H]) + end; + +tokenize([$: | String] = Original, Line, Column, Scope, Tokens) -> + case tokenize_identifier(String, Line, Column, Scope, false) of + {_Kind, Unencoded, Atom, Rest, Length, Ascii, _Special} -> + NewScope = maybe_warn_for_ambiguous_bang_before_equals(atom, Unencoded, Rest, Line, Column, Scope), + TrackedScope = track_ascii(Ascii, NewScope), + Token = {atom, {Line, Column, Unencoded}, Atom}, + tokenize(Rest, Line, Column + 1 + Length, TrackedScope, [Token | Tokens]); + empty when Scope#elixir_tokenizer.cursor_completion == false -> + unexpected_token(Original, Line, Column, Scope, Tokens); + empty -> + tokenize([], Line, Column, Scope, Tokens); + {unexpected_token, Length} -> + unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, Scope, Tokens); + {error, Reason} -> + error(Reason, Original, Scope, Tokens) + end; + +% Integers and floats +% We use int and flt otherwise elixir_parser won't format them +% properly in case of errors. + +tokenize([H | T], Line, Column, Scope, Tokens) when ?is_digit(H) -> + case tokenize_number(T, [H], 1, false) of + {error, Reason, Original} -> + error({?LOC(Line, Column), Reason, Original}, T, Scope, Tokens); + {[I | Rest], Number, Original, _Length} when ?is_upcase(I); ?is_downcase(I); I == $_ -> + if + Number == 0, (I =:= $x) orelse (I =:= $o) orelse (I =:= $b), Rest == [], + Scope#elixir_tokenizer.cursor_completion /= false -> + tokenize([], Line, Column, Scope, Tokens); + + true -> + Msg = + io_lib:format( + "invalid character \"~ts\" after number ~ts. If you intended to write a number, " + "make sure to separate the number from the character (using comma, space, etc). " + "If you meant to write a function name or a variable, note that identifiers in " + "Elixir cannot start with numbers. Unexpected token: ", + [[I], Original] + ), + + error({?LOC(Line, Column), Msg, [I]}, T, Scope, Tokens) + end; + {Rest, Number, Original, Length} when is_integer(Number) -> + Token = {int, {Line, Column, Number}, Original}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + {Rest, Number, Original, Length} -> + Token = {flt, {Line, Column, Number}, Original}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]) + end; + +% Spaces + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?is_horizontal_space(T) -> + {Remaining, Stripped} = strip_horizontal_space(Rest, 0), + handle_space_sensitive_tokens(Remaining, Line, Column + 1 + Stripped, Scope, Tokens); + +% End of line + +tokenize(";" ++ Rest, Line, Column, Scope, []) -> + tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}}]); + +tokenize(";" ++ Rest, Line, Column, Scope, [Top | _] = Tokens) when element(1, Top) /= ';' -> + tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}} | Tokens]); + +tokenize("\\" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\n" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\r\n" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\n" ++ Rest, Line, _Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, Tokens); + +tokenize("\\\r\n" ++ Rest, Line, _Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, Tokens); + +tokenize("\n" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens)); + +tokenize("\r\n" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens)); + +% Others + +tokenize([$%, $( | Rest], Line, Column, Scope, Tokens) -> + Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $(]}, + error(Reason, Rest, Scope, Tokens); + +tokenize([$%, $[ | Rest], Line, Column, Scope, Tokens) -> + Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $[]}, + error(Reason, Rest, Scope, Tokens); + +tokenize([$%, ${ | T], Line, Column, Scope, Tokens) -> + tokenize([${ | T], Line, Column + 1, Scope, [{'%{}', {Line, Column, nil}} | Tokens]); + +tokenize([$% | T], Line, Column, Scope, Tokens) -> + tokenize(T, Line, Column + 1, Scope, [{'%', {Line, Column, nil}} | Tokens]); + +tokenize([$. | T], Line, Column, Scope, Tokens) -> + tokenize_dot(T, Line, Column + 1, {Line, Column, nil}, Scope, Tokens); + +% Identifiers + +tokenize(String, Line, Column, OriginalScope, Tokens) -> + case tokenize_identifier(String, Line, Column, OriginalScope, not previous_was_dot(Tokens)) of + {Kind, Unencoded, Atom, Rest, Length, Ascii, Special} -> + HasAt = lists:member(at, Special), + Scope = track_ascii(Ascii, OriginalScope), + + case Rest of + [$: | T] when ?is_space(hd(T)) -> + Token = {kw_identifier, {Line, Column, Unencoded}, Atom}, + tokenize(T, Line, Column + Length + 1, Scope, [Token | Tokens]); + + [$: | T] when hd(T) =/= $: -> + AtomName = atom_to_list(Atom) ++ [$:], + Reason = {?LOC(Line, Column), "keyword argument must be followed by space after: ", AtomName}, + error(Reason, String, Scope, Tokens); + + _ when HasAt -> + Reason = {?LOC(Line, Column), invalid_character_error(Kind, $@), atom_to_list(Atom)}, + error(Reason, String, Scope, Tokens); + + _ when Atom == '__aliases__'; Atom == '__block__' -> + error({?LOC(Line, Column), "reserved token: ", atom_to_list(Atom)}, Rest, Scope, Tokens); + + _ when Kind == alias -> + tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens); + + _ when Kind == identifier -> + NewScope = maybe_warn_for_ambiguous_bang_before_equals(identifier, Unencoded, Rest, Line, Column, Scope), + Token = check_call_identifier(Line, Column, Unencoded, Atom, Rest), + tokenize(Rest, Line, Column + Length, NewScope, [Token | Tokens]); + + _ -> + unexpected_token(String, Line, Column, Scope, Tokens) + end; + + {keyword, Atom, Type, Rest, Length} -> + tokenize_keyword(Type, Rest, Line, Column, Atom, Length, OriginalScope, Tokens); + + empty when OriginalScope#elixir_tokenizer.cursor_completion == false -> + unexpected_token(String, Line, Column, OriginalScope, Tokens); + + empty -> + case String of + [$~, L] when ?is_upcase(L); ?is_downcase(L) -> tokenize([], Line, Column, OriginalScope, Tokens); + [$~] -> tokenize([], Line, Column, OriginalScope, Tokens); + _ -> unexpected_token(String, Line, Column, OriginalScope, Tokens) + end; + + {unexpected_token, Length} -> + unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, OriginalScope, Tokens); + + {error, Reason} -> + error(Reason, String, OriginalScope, Tokens) + end. + +previous_was_dot([{'.', _} | _]) -> true; +previous_was_dot(_) -> false. + +unexpected_token([T | Rest], Line, Column, Scope, Tokens) -> + Message = + case handle_char(T) of + {_Escaped, Explanation} -> + io_lib:format("~ts (column ~p, code point U+~4.16.0B)", [Explanation, Column, T]); + false -> + io_lib:format("\"~ts\" (column ~p, code point U+~4.16.0B)", [[T], Column, T]) + end, + error({?LOC(Line, Column), "unexpected token: ", Message}, Rest, Scope, Tokens). + +tokenize_eol(Rest, Line, Scope, Tokens) -> + {StrippedRest, Column} = strip_horizontal_space(Rest, Scope#elixir_tokenizer.column), + IndentedScope = Scope#elixir_tokenizer{indentation=Column-1}, + tokenize(StrippedRest, Line + 1, Column, IndentedScope, Tokens). + +strip_horizontal_space([H | T], Counter) when ?is_horizontal_space(H) -> + strip_horizontal_space(T, Counter + 1); +strip_horizontal_space(T, Counter) -> + {T, Counter}. + +tokenize_dot(T, Line, Column, DotInfo, Scope, Tokens) -> + case strip_horizontal_space(T, 0) of + {[$# | R], _} -> + case tokenize_comment(R, [$#]) of + {error, Char} -> + error_comment(Char, [$# | R], Line, Column, Scope, Tokens); + + {Rest, Comment} -> + preserve_comments(Line, Column, Tokens, Comment, Rest, Scope), + tokenize_dot(Rest, Line, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens) + end; + {"\r\n" ++ Rest, _} -> + tokenize_dot(Rest, Line + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens); + {"\n" ++ Rest, _} -> + tokenize_dot(Rest, Line + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens); + {Rest, Length} -> + handle_dot([$. | Rest], Line, Column + Length, DotInfo, Scope, Tokens) + end. + +handle_char(0) -> {"\\0", "null byte"}; +handle_char(7) -> {"\\a", "alert"}; +handle_char($\b) -> {"\\b", "backspace"}; +handle_char($\d) -> {"\\d", "delete"}; +handle_char($\e) -> {"\\e", "escape"}; +handle_char($\f) -> {"\\f", "form feed"}; +handle_char($\n) -> {"\\n", "newline"}; +handle_char($\r) -> {"\\r", "carriage return"}; +handle_char($\s) -> {"\\s", "space"}; +handle_char($\t) -> {"\\t", "tab"}; +handle_char($\v) -> {"\\v", "vertical tab"}; +handle_char(_) -> false. + +%% Handlers + +handle_heredocs(T, Line, Column, H, Scope, Tokens) -> + case extract_heredoc_with_interpolation(Line, Column, Scope, true, T, H) of + {ok, NewLine, NewColumn, Parts, Rest, NewScope} -> + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, Unescaped} -> + Token = {heredoc_type(H), {Line, Column, nil}, NewColumn - 4, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, Scope, Tokens) + end; + + {error, Reason} -> + error(Reason, [H, H, H] ++ T, Scope, Tokens) + end. + +handle_strings(T, Line, Column, H, Scope, Tokens) -> + case future_elixir_interpolation:extract(Line, Column, Scope, true, T, H) of + {error, Reason} -> + interpolation_error(Reason, [H | T], Scope, Tokens, " (for string starting at line ~B)", [Line], Line, Column-1, [H], [H]); + + {NewLine, NewColumn, Parts, [$: | Rest], InterScope} when ?is_space(hd(Rest)) -> + NewScope = case is_unnecessary_quote(Parts, InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted keyword \"~ts\" but the quotes are not required. " + "Note that keywords are always atoms, even when quoted. " + "Similar to atoms, keywords made exclusively of ASCII " + "letters, numbers, and underscores and not beginning with a " + "number do not require quotes", + [hd(Parts)] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, [Part]} when is_binary(Part) -> + case unsafe_to_atom(Part, Line, Column - 1, Scope) of + {ok, Atom} -> + Token = {kw_identifier, {Line, Column - 1, nil}, Atom}, + tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]); + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {ok, Unescaped} -> + Key = case Scope#elixir_tokenizer.existing_atoms_only of + true -> kw_identifier_safe; + false -> kw_identifier_unsafe + end, + Token = {Key, {Line, Column - 1, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {NewLine, NewColumn, Parts, Rest, NewScope} -> + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, Unescaped} -> + Token = {string_type(H), {Line, Column - 1, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end + end. + +handle_unary_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) -> + Token = {kw_identifier, {Line, Column, nil}, Op}, + tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]); + +handle_unary_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]); + {Remaining, Extra} -> + Token = {Kind, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]) + end. + +handle_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) -> + Token = {kw_identifier, {Line, Column, nil}, Op}, + tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]); + +handle_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]); + {Remaining, Extra} -> + NewScope = + %% TODO: Remove these deprecations on Elixir v2.0 + case Op of + '^^^' -> + Msg = "^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead", + prepend_warning(Line, Column, Msg, Scope); + + '~~~' -> + Msg = "~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity", + prepend_warning(Line, Column, Msg, Scope); + + '<|>' -> + Msg = "<|> is deprecated. Use another pipe-like operator", + prepend_warning(Line, Column, Msg, Scope); + + _ -> + Scope + end, + + Token = {Kind, {Line, Column, previous_was_eol(Tokens)}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, NewScope, add_token_with_eol(Token, Tokens)) + end. + +% ## Three Token Operators +handle_dot([$., T1, T2, T3 | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3); + ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 3, [T1, T2, T3], Scope, Tokens); + +% ## Two Token Operators +handle_dot([$., T1, T2 | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); + ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2); + ?type_op(T1, T2) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 2, [T1, T2], Scope, Tokens); + +% ## Single Token Operators +handle_dot([$., T | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T); + ?rel_op(T); ?match_op(T); ?pipe_op(T) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 1, [T], Scope, Tokens); + +% ## Exception for .( as it needs to be treated specially in the parser +handle_dot([$., $( | Rest], Line, Column, DotInfo, Scope, Tokens) -> + TokensSoFar = add_token_with_eol({dot_call_op, DotInfo, '.'}, Tokens), + tokenize([$( | Rest], Line, Column, Scope, TokensSoFar); + +handle_dot([$., H | T] = Original, Line, Column, DotInfo, Scope, Tokens) when ?is_quote(H) -> + case future_elixir_interpolation:extract(Line, Column + 1, Scope, true, T, H) of + {NewLine, NewColumn, [Part], Rest, InterScope} when is_list(Part) -> + NewScope = case is_unnecessary_quote([Part], InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted call \"~ts\" but the quotes are not required. " + "Calls made exclusively of Unicode letters, numbers, and underscores " + "and not beginning with a number do not require quotes", + [Part] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unsafe_to_atom(Part, Line, Column, NewScope) of + {ok, Atom} -> + Token = check_call_identifier(Line, Column, Part, Atom, Rest), + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | TokensSoFar]); + + {error, Reason} -> + error(Reason, Original, NewScope, Tokens) + end; + {_NewLine, _NewColumn, _Parts, Rest, NewScope} -> + Message = "interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: ", + error({?LOC(Line, Column), Message, [H]}, Rest, NewScope, Tokens); + {error, Reason} -> + interpolation_error(Reason, Original, Scope, Tokens, " (for function name starting at line ~B)", [Line], Line, Column, [H], [H]) + end; + +handle_dot([$. | Rest], Line, Column, DotInfo, Scope, Tokens) -> + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, Line, Column, Scope, TokensSoFar). + +handle_call_identifier(Rest, Line, Column, DotInfo, Length, UnencodedOp, Scope, Tokens) -> + Token = check_call_identifier(Line, Column, UnencodedOp, list_to_atom(UnencodedOp), Rest), + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, Line, Column + Length, Scope, [Token | TokensSoFar]). + +% ## Ambiguous unary/binary operators tokens +% Keywords are not ambiguous operators +handle_space_sensitive_tokens([Sign, $:, Space | _] = String, Line, Column, Scope, Tokens) when ?dual_op(Sign), ?is_space(Space) -> + tokenize(String, Line, Column, Scope, Tokens); + +% But everything else, except other operators, are +handle_space_sensitive_tokens([Sign, NotMarker | T], Line, Column, Scope, [{identifier, _, _} = H | Tokens]) when + ?dual_op(Sign), not(?is_space(NotMarker)), NotMarker =/= Sign, NotMarker =/= $/, NotMarker =/= $> -> + Rest = [NotMarker | T], + DualOpToken = {dual_op, {Line, Column, nil}, list_to_atom([Sign])}, + tokenize(Rest, Line, Column + 1, Scope, [DualOpToken, setelement(1, H, op_identifier) | Tokens]); + +% Handle cursor completion +handle_space_sensitive_tokens([], Line, Column, + #elixir_tokenizer{cursor_completion=Cursor} = Scope, + [{identifier, Info, Identifier} | Tokens]) when Cursor /= false -> + tokenize([$(], Line, Column+1, Scope, [{paren_identifier, Info, Identifier} | Tokens]); + +handle_space_sensitive_tokens(String, Line, Column, Scope, Tokens) -> + tokenize(String, Line, Column, Scope, Tokens). + +%% Helpers + +eol(_Line, _Column, [{',', {Line, Column, Count}} | Tokens]) -> + [{',', {Line, Column, Count + 1}} | Tokens]; +eol(_Line, _Column, [{';', {Line, Column, Count}} | Tokens]) -> + [{';', {Line, Column, Count + 1}} | Tokens]; +eol(_Line, _Column, [{eol, {Line, Column, Count}} | Tokens]) -> + [{eol, {Line, Column, Count + 1}} | Tokens]; +eol(Line, Column, Tokens) -> + [{eol, {Line, Column, 1}} | Tokens]. + +is_unnecessary_quote([Part], Scope) when is_list(Part) -> + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(Part) of + {identifier, _, [], _, true, Special} -> not lists:member(at, Special); + _ -> false + end; +is_unnecessary_quote(_Parts, _Scope) -> + false. + +unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{}) when + is_binary(Part) andalso byte_size(Part) > 255; + is_list(Part) andalso length(Part) > 255 -> + {error, {?LOC(Line, Column), "atom length must be less than system limit: ", elixir_utils:characters_to_list(Part)}}; +unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}) when + is_function(StaticAtomsEncoder) -> + Value = elixir_utils:characters_to_binary(Part), + case StaticAtomsEncoder(Value, [{line, Line}, {column, Column}]) of + {ok, Term} -> + {ok, Term}; + {error, Reason} when is_binary(Reason) -> + {error, {?LOC(Line, Column), elixir_utils:characters_to_list(Reason) ++ ": ", elixir_utils:characters_to_list(Part)}} + end; +unsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_binary(Binary) -> + try + {ok, binary_to_existing_atom(Binary, utf8)} + catch + error:badarg -> {error, {?LOC(Line, Column), "unsafe atom does not exist: ", elixir_utils:characters_to_list(Binary)}} + end; +unsafe_to_atom(Binary, _Line, _Column, #elixir_tokenizer{}) when is_binary(Binary) -> + {ok, binary_to_atom(Binary, utf8)}; +unsafe_to_atom(List, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_list(List) -> + try + {ok, list_to_existing_atom(List)} + catch + error:badarg -> {error, {?LOC(Line, Column), "unsafe atom does not exist: ", List}} + end; +unsafe_to_atom(List, _Line, _Column, #elixir_tokenizer{}) when is_list(List) -> + {ok, list_to_atom(List)}. + +collect_modifiers([H | T], Buffer) when ?is_downcase(H) or ?is_upcase(H) or ?is_digit(H) -> + collect_modifiers(T, [H | Buffer]); + +collect_modifiers(Rest, Buffer) -> + {Rest, lists:reverse(Buffer)}. + +%% Heredocs + +extract_heredoc_with_interpolation(Line, Column, Scope, Interpol, T, H) -> + case extract_heredoc_header(T) of + {ok, Headerless} -> + %% We prepend a new line so we can transparently remove + %% spaces later. This new line is removed by calling "tl" + %% in the final heredoc body three lines below. + case future_elixir_interpolation:extract(Line, Column, Scope, Interpol, [$\n|Headerless], [H,H,H]) of + {NewLine, NewColumn, Parts0, Rest, InterScope} -> + Indent = NewColumn - 4, + Fun = fun(Part, Acc) -> extract_heredoc_indent(Part, Acc, Indent) end, + {Parts1, {ShouldWarn, _}} = lists:mapfoldl(Fun, {false, Line}, Parts0), + Parts2 = extract_heredoc_head(Parts1), + NewScope = maybe_heredoc_warn(ShouldWarn, Column, InterScope, H), + {ok, NewLine, NewColumn, tokens_to_binary(Parts2), Rest, NewScope}; + + {error, Reason} -> + {error, interpolation_format(Reason, " (for heredoc starting at line ~B)", [Line], Line, Column, [H, H, H], [H, H, H])} + end; + + error -> + Message = "heredoc allows only whitespace characters followed by a new line after opening ", + {error, {?LOC(Line, Column + 3), io_lib:format(Message, []), [H, H, H]}} + end. + +extract_heredoc_header("\r\n" ++ Rest) -> + {ok, Rest}; +extract_heredoc_header("\n" ++ Rest) -> + {ok, Rest}; +extract_heredoc_header([H | T]) when ?is_horizontal_space(H) -> + extract_heredoc_header(T); +extract_heredoc_header(_) -> + error. + +extract_heredoc_indent(Part, {Warned, Line}, Indent) when is_list(Part) -> + extract_heredoc_indent(Part, [], Warned, Line, Indent); +extract_heredoc_indent({_, {EndLine, _, _}, _} = Part, {Warned, _Line}, _Indent) -> + {Part, {Warned, EndLine}}. + +extract_heredoc_indent([$\n | Rest], Acc, Warned, Line, Indent) -> + {Trimmed, ShouldWarn} = trim_space(Rest, Indent), + Warn = if ShouldWarn, not Warned -> Line + 1; true -> Warned end, + extract_heredoc_indent(Trimmed, [$\n | Acc], Warn, Line + 1, Indent); +extract_heredoc_indent([Head | Rest], Acc, Warned, Line, Indent) -> + extract_heredoc_indent(Rest, [Head | Acc], Warned, Line, Indent); +extract_heredoc_indent([], Acc, Warned, Line, _Indent) -> + {lists:reverse(Acc), {Warned, Line}}. + +trim_space(Rest, 0) -> {Rest, false}; +trim_space([$\r, $\n | _] = Rest, _) -> {Rest, false}; +trim_space([$\n | _] = Rest, _) -> {Rest, false}; +trim_space([H | T], Spaces) when ?is_horizontal_space(H) -> trim_space(T, Spaces - 1); +trim_space([], _Spaces) -> {[], false}; +trim_space(Rest, _Spaces) -> {Rest, true}. + +maybe_heredoc_warn(false, _Column, Scope, _Marker) -> + Scope; +maybe_heredoc_warn(Line, Column, Scope, Marker) -> + Msg = io_lib:format("outdented heredoc line. The contents inside the heredoc should be indented " + "at the same level as the closing ~ts. The following is forbidden:~n~n" + " def text do~n" + " \"\"\"~n" + " contents~n" + " \"\"\"~n" + " end~n~n" + "Instead make sure the contents are indented as much as the heredoc closing:~n~n" + " def text do~n" + " \"\"\"~n" + " contents~n" + " \"\"\"~n" + " end~n~n" + "The current heredoc line is indented too little", [[Marker, Marker, Marker]]), + + prepend_warning(Line, Column, Msg, Scope). + +extract_heredoc_head([[$\n|H]|T]) -> [H|T]. + +unescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=true}) -> + case future_elixir_interpolation:unescape_tokens(Tokens) of + {ok, Result} -> + {ok, Result}; + + {error, Message, Token} -> + {error, {?LOC(Line, Column), Message ++ ". Syntax error after: ", Token}} + end; +unescape_tokens(Tokens, _Line, _Column, #elixir_tokenizer{unescape=false}) -> + {ok, tokens_to_binary(Tokens)}. + +tokens_to_binary(Tokens) -> + [if is_list(Token) -> elixir_utils:characters_to_binary(Token); true -> Token end + || Token <- Tokens]. + +%% Integers and floats +%% At this point, we are at least sure the first digit is a number. + +%% Check if we have a point followed by a number; +tokenize_number([$., H | T], Acc, Length, false) when ?is_digit(H) -> + tokenize_number(T, [H, $. | Acc], Length + 2, true); + +%% Check if we have an underscore followed by a number; +tokenize_number([$_, H | T], Acc, Length, Bool) when ?is_digit(H) -> + tokenize_number(T, [H, $_ | Acc], Length + 2, Bool); + +%% Check if we have e- followed by numbers (valid only for floats); +tokenize_number([E, S, H | T], Acc, Length, true) + when (E =:= $E) or (E =:= $e), ?is_digit(H), S =:= $+ orelse S =:= $- -> + tokenize_number(T, [H, S, E | Acc], Length + 3, true); + +%% Check if we have e followed by numbers (valid only for floats); +tokenize_number([E, H | T], Acc, Length, true) + when (E =:= $E) or (E =:= $e), ?is_digit(H) -> + tokenize_number(T, [H, E | Acc], Length + 2, true); + +%% Finally just numbers. +tokenize_number([H | T], Acc, Length, Bool) when ?is_digit(H) -> + tokenize_number(T, [H | Acc], Length + 1, Bool); + +%% Cast to float... +tokenize_number(Rest, Acc, Length, true) -> + try + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_float(Number), Original, Length} + catch + error:badarg -> {error, "invalid float number ", lists:reverse(Acc)} + end; + +%% Or integer. +tokenize_number(Rest, Acc, Length, false) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number), Original, Length}. + +tokenize_hex([H | T], Acc, Length) when ?is_hex(H) -> + tokenize_hex(T, [H | Acc], Length + 1); +tokenize_hex([$_, H | T], Acc, Length) when ?is_hex(H) -> + tokenize_hex(T, [H, $_ | Acc], Length + 2); +tokenize_hex(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 16), [$0, $x | Original], Length}. + +tokenize_octal([H | T], Acc, Length) when ?is_octal(H) -> + tokenize_octal(T, [H | Acc], Length + 1); +tokenize_octal([$_, H | T], Acc, Length) when ?is_octal(H) -> + tokenize_octal(T, [H, $_ | Acc], Length + 2); +tokenize_octal(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 8), [$0, $o | Original], Length}. + +tokenize_bin([H | T], Acc, Length) when ?is_bin(H) -> + tokenize_bin(T, [H | Acc], Length + 1); +tokenize_bin([$_, H | T], Acc, Length) when ?is_bin(H) -> + tokenize_bin(T, [H, $_ | Acc], Length + 2); +tokenize_bin(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 2), [$0, $b | Original], Length}. + +reverse_number([$_ | T], Number, Original) -> + reverse_number(T, Number, [$_ | Original]); +reverse_number([H | T], Number, Original) -> + reverse_number(T, [H | Number], [H | Original]); +reverse_number([], Number, Original) -> + {Number, Original}. + +%% Comments + +reset_eol([{eol, {Line, Column, _}} | Rest]) -> [{eol, {Line, Column, 0}} | Rest]; +reset_eol(Rest) -> Rest. + +tokenize_comment("\r\n" ++ _ = Rest, Acc) -> + {Rest, lists:reverse(Acc)}; +tokenize_comment("\n" ++ _ = Rest, Acc) -> + {Rest, lists:reverse(Acc)}; +tokenize_comment([H | _Rest], _) when ?bidi(H) -> + {error, H}; +tokenize_comment([H | Rest], Acc) -> + tokenize_comment(Rest, [H | Acc]); +tokenize_comment([], Acc) -> + {[], lists:reverse(Acc)}. + +error_comment(H, Comment, Line, Column, Scope, Tokens) -> + Token = io_lib:format("\\u~4.16.0B", [H]), + Reason = {?LOC(Line, Column), "invalid bidirectional formatting character in comment: ", Token}, + error(Reason, Comment, Scope, Tokens). + +preserve_comments(Line, Column, Tokens, Comment, Rest, Scope) -> + case Scope#elixir_tokenizer.preserve_comments of + Fun when is_function(Fun) -> + Fun(Line, Column, Tokens, Comment, Rest); + nil -> + ok + end. + +%% Identifiers + +tokenize([H | T]) when ?is_upcase(H) -> + {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []), + {alias, lists:reverse(Acc), Rest, Length, true, Special}; +tokenize([H | T]) when ?is_downcase(H); H =:= $_ -> + {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []), + {identifier, lists:reverse(Acc), Rest, Length, true, Special}; +tokenize(_List) -> + {error, empty}. + +tokenize_continue([$@ | T], Acc, Length, Special) -> + tokenize_continue(T, [$@ | Acc], Length + 1, [at | lists:delete(at, Special)]); +tokenize_continue([$! | T], Acc, Length, Special) -> + {[$! | Acc], T, Length + 1, [punctuation | Special]}; +tokenize_continue([$? | T], Acc, Length, Special) -> + {[$? | Acc], T, Length + 1, [punctuation | Special]}; +tokenize_continue([H | T], Acc, Length, Special) when ?is_upcase(H); ?is_downcase(H); ?is_digit(H); H =:= $_ -> + tokenize_continue(T, [H | Acc], Length + 1, Special); +tokenize_continue(Rest, Acc, Length, Special) -> + {Acc, Rest, Length, Special}. + +tokenize_identifier(String, Line, Column, Scope, MaybeKeyword) -> + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(String) of + {Kind, Acc, Rest, Length, Ascii, Special} -> + Keyword = MaybeKeyword andalso maybe_keyword(Rest), + + case keyword_or_unsafe_to_atom(Keyword, Acc, Line, Column, Scope) of + {keyword, Atom, Type} -> + {keyword, Atom, Type, Rest, Length}; + {ok, Atom} -> + {Kind, Acc, Atom, Rest, Length, Ascii, Special}; + {error, _Reason} = Error -> + Error + end; + + {error, {not_highly_restrictive, Wrong, {Prefix, Suffix}}} -> + WrongColumn = Column + length(Wrong) - 1, + case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of + no_suggestion -> + %% we append a pointer to more info if we aren't appending a suggestion + MoreInfo = "\nSee https://hexdocs.pm/elixir/unicode-syntax.html for more information.", + {error, {?LOC(Line, Column), {Prefix, Suffix ++ MoreInfo}, Wrong}}; + + {_, {Location, _, SuggestionMessage}} = _SuggestionError -> + {error, {Location, {Prefix, Suffix ++ SuggestionMessage}, Wrong}} + end; + + {error, {unexpected_token, Wrong}} -> + WrongColumn = Column + length(Wrong) - 1, + case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of + no_suggestion -> + [T | _] = lists:reverse(Wrong), + case suggest_simpler_unexpected_token_in_error([T], Line, WrongColumn, Scope) of + no_suggestion -> {unexpected_token, length(Wrong)}; + SuggestionError -> SuggestionError + end; + + SuggestionError -> + SuggestionError + end; + + {error, empty} -> + empty + end. + +%% heuristic: try nfkc; try confusability skeleton; try calling this again w/just failed codepoint +suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) -> + NFKC = unicode:characters_to_nfkc_list(Wrong), + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(NFKC) of + {error, _Reason} -> + ConfusableSkeleton = 'Elixir.String.Tokenizer.Security':confusable_skeleton(Wrong), + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(ConfusableSkeleton) of + {_, Simpler, _, _, _, _} -> + Message = suggest_change("Codepoint failed identifier tokenization, but a simpler form was found.", + Wrong, + "You could write the above in a similar way that is accepted by Elixir:", + Simpler, + "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."), + {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}}; + _other -> + no_suggestion + end; + {_, _NFKC, _, _, _, _} -> + Message = suggest_change("Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.", + Wrong, + "You could write the above in a compatible format that is accepted by Elixir:", + NFKC, + "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."), + {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}} + end. + +suggest_change(Intro, WrongForm, Hint, HintedForm, Ending) -> + WrongCodepoints = list_to_codepoint_hex(WrongForm), + HintedCodepoints = list_to_codepoint_hex(HintedForm), + io_lib:format("~ts\n\nGot:\n\n \"~ts\" (code points~ts)\n\n" + "Hint: ~ts\n\n \"~ts\" (code points~ts)\n\n~ts", + [Intro, WrongForm, WrongCodepoints, Hint, HintedForm, HintedCodepoints, Ending]). + +maybe_keyword([]) -> true; +maybe_keyword([$:, $: | _]) -> true; +maybe_keyword([$: | _]) -> false; +maybe_keyword(_) -> true. + +list_to_codepoint_hex(List) -> + [io_lib:format(" 0x~5.16.0B", [Codepoint]) || Codepoint <- List]. + +tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens) -> + if + not Ascii or (Special /= []) -> + Invalid = hd([C || C <- Unencoded, (C < $A) or (C > 127)]), + Reason = {?LOC(Line, Column), invalid_character_error("alias (only ASCII characters, without punctuation, are allowed)", Invalid), Unencoded}, + error(Reason, Unencoded ++ Rest, Scope, Tokens); + + true -> + AliasesToken = {alias, {Line, Column, Unencoded}, Atom}, + tokenize(Rest, Line, Column + Length, Scope, [AliasesToken | Tokens]) + end. + +%% Check if it is a call identifier (paren | bracket | do) + +check_call_identifier(Line, Column, Unencoded, Atom, [$( | _]) -> + {paren_identifier, {Line, Column, Unencoded}, Atom}; +check_call_identifier(Line, Column, Unencoded, Atom, [$[ | _]) -> + {bracket_identifier, {Line, Column, Unencoded}, Atom}; +check_call_identifier(Line, Column, Unencoded, Atom, _Rest) -> + {identifier, {Line, Column, Unencoded}, Atom}. + +add_token_with_eol({unary_op, _, _} = Left, T) -> [Left | T]; +add_token_with_eol(Left, [{eol, _} | T]) -> [Left | T]; +add_token_with_eol(Left, T) -> [Left | T]. + +previous_was_eol([{',', {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol([{';', {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol([{eol, {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol(_) -> nil. + +%% Error handling + +interpolation_error(Reason, Rest, Scope, Tokens, Extension, Args, Line, Column, Opening, Closing) -> + error(interpolation_format(Reason, Extension, Args, Line, Column, Opening, Closing), Rest, Scope, Tokens). + +interpolation_format({string, EndLine, EndColumn, Message, Token}, Extension, Args, Line, Column, Opening, Closing) -> + Meta = [ + {opening_delimiter, list_to_atom(Opening)}, + {expected_delimiter, list_to_atom(Closing)}, + {line, Line}, + {column, Column}, + {end_line, EndLine}, + {end_column, EndColumn} + ], + {Meta, [Message, io_lib:format(Extension, Args)], Token}; +interpolation_format({_, _, _} = Reason, _Extension, _Args, _Line, _Column, _Opening, _Closing) -> + Reason. + +%% Terminators + +handle_terminator(Rest, _, _, Scope, {'(', {Line, Column, _}}, [{alias, _, Alias} | Tokens]) -> + Reason = + io_lib:format( + "unexpected ( after alias ~ts. Function names and identifiers in Elixir " + "start with lowercase characters or underscore. For example:\n\n" + " hello_world()\n" + " _starting_with_underscore()\n" + " numb3rs_are_allowed()\n" + " may_finish_with_question_mark?()\n" + " may_finish_with_exclamation_mark!()\n\n" + "Unexpected token: ", + [Alias] + ), + + error({?LOC(Line, Column), Reason, ["("]}, atom_to_list(Alias) ++ [$( | Rest], Scope, Tokens); +handle_terminator(Rest, Line, Column, #elixir_tokenizer{terminators=none} = Scope, Token, Tokens) -> + tokenize(Rest, Line, Column, Scope, [Token | Tokens]); +handle_terminator(Rest, Line, Column, Scope, Token, Tokens) -> + #elixir_tokenizer{terminators=Terminators} = Scope, + + case check_terminator(Token, Terminators, Scope) of + {error, Reason} -> + error(Reason, atom_to_list(element(1, Token)) ++ Rest, Scope, Tokens); + {ok, New} -> + tokenize(Rest, Line, Column, New, [Token | Tokens]) + end. + +check_terminator({Start, Meta}, Terminators, Scope) + when Start == '('; Start == '['; Start == '{'; Start == '<<' -> + Indentation = Scope#elixir_tokenizer.indentation, + {ok, Scope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}}; + +check_terminator({Start, Meta}, Terminators, Scope) when Start == 'fn'; Start == 'do' -> + Indentation = Scope#elixir_tokenizer.indentation, + + NewScope = + case Terminators of + %% If the do is indented equally or less than the previous do, it may be a missing end error! + [{Start, _, PreviousIndentation} = Previous | _] when Indentation =< PreviousIndentation -> + Scope#elixir_tokenizer{mismatch_hints=[Previous | Scope#elixir_tokenizer.mismatch_hints]}; + + _ -> + Scope + end, + + {ok, NewScope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}}; + +check_terminator({'end', {EndLine, _, _}}, [{'do', _, Indentation} | Terminators], Scope) -> + NewScope = + %% If the end is more indented than the do, it may be a missing do error! + case Scope#elixir_tokenizer.indentation > Indentation of + true -> + Hint = {'end', EndLine, Scope#elixir_tokenizer.indentation}, + Scope#elixir_tokenizer{mismatch_hints=[Hint | Scope#elixir_tokenizer.mismatch_hints]}; + + false -> + Scope + end, + + {ok, NewScope#elixir_tokenizer{terminators=Terminators}}; + +check_terminator({End, {EndLine, EndColumn, _}}, [{Start, {StartLine, StartColumn, _}, _} | Terminators], Scope) + when End == 'end'; End == ')'; End == ']'; End == '}'; End == '>>' -> + case terminator(Start) of + End -> + {ok, Scope#elixir_tokenizer{terminators=Terminators}}; + + ExpectedEnd -> + Meta = [ + {line, StartLine}, + {column, StartColumn}, + {end_line, EndLine}, + {end_column, EndColumn}, + {error_type, mismatched_delimiter}, + {opening_delimiter, Start}, + {closing_delimiter, End}, + {expected_delimiter, ExpectedEnd} + ], + {error, {Meta, unexpected_token_or_reserved(End), [atom_to_list(End)]}} + end; + +check_terminator({'end', {Line, Column, _}}, [], #elixir_tokenizer{mismatch_hints=Hints}) -> + Suffix = + case lists:keyfind('end', 1, Hints) of + {'end', HintLine, _Identation} -> + io_lib:format("\n~ts the \"end\" on line ~B may not have a matching \"do\" " + "defined before it (based on indentation)", [future_elixir_errors:prefix(hint), HintLine]); + false -> + "" + end, + + {error, {?LOC(Line, Column), {"unexpected reserved word: ", Suffix}, "end"}}; + +check_terminator({End, {Line, Column, _}}, [], _Scope) + when End == ')'; End == ']'; End == '}'; End == '>>' -> + {error, {?LOC(Line, Column), "unexpected token: ", atom_to_list(End)}}; + +check_terminator(_, _, Scope) -> + {ok, Scope}. + +unexpected_token_or_reserved('end') -> "unexpected reserved word: "; +unexpected_token_or_reserved(_) -> "unexpected token: ". + +missing_terminator_hint(Start, End, #elixir_tokenizer{mismatch_hints=Hints}) -> + case lists:keyfind(Start, 1, Hints) of + {Start, {HintLine, _, _}, _} -> + io_lib:format("\n~ts it looks like the \"~ts\" on line ~B does not have a matching \"~ts\"", + [future_elixir_errors:prefix(hint), Start, HintLine, End]); + false -> + "" + end. + +string_type($") -> bin_string; +string_type($') -> list_string. + +heredoc_type($") -> bin_heredoc; +heredoc_type($') -> list_heredoc. + +sigil_terminator($() -> $); +sigil_terminator($[) -> $]; +sigil_terminator(${) -> $}; +sigil_terminator($<) -> $>; +sigil_terminator(O) -> O. + +terminator('fn') -> 'end'; +terminator('do') -> 'end'; +terminator('(') -> ')'; +terminator('[') -> ']'; +terminator('{') -> '}'; +terminator('<<') -> '>>'. + +%% Keywords checking + +keyword_or_unsafe_to_atom(true, "fn", _Line, _Column, _Scope) -> {keyword, 'fn', terminator}; +keyword_or_unsafe_to_atom(true, "do", _Line, _Column, _Scope) -> {keyword, 'do', terminator}; +keyword_or_unsafe_to_atom(true, "end", _Line, _Column, _Scope) -> {keyword, 'end', terminator}; +keyword_or_unsafe_to_atom(true, "true", _Line, _Column, _Scope) -> {keyword, 'true', token}; +keyword_or_unsafe_to_atom(true, "false", _Line, _Column, _Scope) -> {keyword, 'false', token}; +keyword_or_unsafe_to_atom(true, "nil", _Line, _Column, _Scope) -> {keyword, 'nil', token}; + +keyword_or_unsafe_to_atom(true, "not", _Line, _Column, _Scope) -> {keyword, 'not', unary_op}; +keyword_or_unsafe_to_atom(true, "and", _Line, _Column, _Scope) -> {keyword, 'and', and_op}; +keyword_or_unsafe_to_atom(true, "or", _Line, _Column, _Scope) -> {keyword, 'or', or_op}; +keyword_or_unsafe_to_atom(true, "when", _Line, _Column, _Scope) -> {keyword, 'when', when_op}; +keyword_or_unsafe_to_atom(true, "in", _Line, _Column, _Scope) -> {keyword, 'in', in_op}; + +keyword_or_unsafe_to_atom(true, "after", _Line, _Column, _Scope) -> {keyword, 'after', block}; +keyword_or_unsafe_to_atom(true, "else", _Line, _Column, _Scope) -> {keyword, 'else', block}; +keyword_or_unsafe_to_atom(true, "catch", _Line, _Column, _Scope) -> {keyword, 'catch', block}; +keyword_or_unsafe_to_atom(true, "rescue", _Line, _Column, _Scope) -> {keyword, 'rescue', block}; + +keyword_or_unsafe_to_atom(_, Part, Line, Column, Scope) -> + unsafe_to_atom(Part, Line, Column, Scope). + +tokenize_keyword(terminator, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + case tokenize_keyword_terminator(Line, Column, Atom, Tokens) of + {ok, [Check | T]} -> + handle_terminator(Rest, Line, Column + Length, Scope, Check, T); + {error, Message, Token} -> + error({?LOC(Line, Column), Message, Token}, Token ++ Rest, Scope, Tokens) + end; + +tokenize_keyword(token, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + Token = {Atom, {Line, Column, nil}}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + +tokenize_keyword(block, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + Token = {block_identifier, {Line, Column, nil}, Atom}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + +tokenize_keyword(Kind, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + NewTokens = + case strip_horizontal_space(Rest, 0) of + {[$/ | _], _} -> + [{identifier, {Line, Column, nil}, Atom} | Tokens]; + + _ -> + case {Kind, Tokens} of + {in_op, [{unary_op, NotInfo, 'not'} | T]} -> + add_token_with_eol({in_op, NotInfo, 'not in'}, T); + + {_, _} -> + add_token_with_eol({Kind, {Line, Column, previous_was_eol(Tokens)}, Atom}, Tokens) + end + end, + + tokenize(Rest, Line, Column + Length, Scope, NewTokens). + +tokenize_sigil([$~ | T], Line, Column, Scope, Tokens) -> + case tokenize_sigil_name(T, [], Line, Column + 1, Scope, Tokens) of + {ok, Name, Rest, NewLine, NewColumn, NewScope, NewTokens} -> + tokenize_sigil_contents(Rest, Name, NewLine, NewColumn, NewScope, NewTokens); + + {error, Message, Token} -> + Reason = {?LOC(Line, Column), Message, Token}, + error(Reason, T, Scope, Tokens) + end. + +% A one-letter sigil is ok both as upcase as well as downcase. +tokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_upcase(S) orelse ?is_downcase(S) -> + tokenize_sigil_name(T, [S], Line, Column + 1, Scope, Tokens); +% If we have an uppercase letter, we keep tokenizing the name. +tokenize_sigil_name([S | T], NameAcc, Line, Column, Scope, Tokens) when ?is_upcase(S) -> + tokenize_sigil_name(T, [S | NameAcc], Line, Column + 1, Scope, Tokens); +% With a lowercase letter and a non-empty NameAcc we return an error. +tokenize_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) -> + Message = "invalid sigil name, it should be either a one-letter lowercase letter or a" ++ + " sequence of uppercase letters only, got: ", + {error, Message, [$~] ++ lists:reverse(NameAcc) ++ Original}; +% We finished the letters, so the name is over. +tokenize_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) -> + {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}. + +tokenize_sigil_contents([H, H, H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens) + when ?is_quote(H) -> + case extract_heredoc_with_interpolation(Line, Column, Scope, ?is_downcase(S), T, H) of + {ok, NewLine, NewColumn, Parts, Rest, NewScope} -> + Indentation = NewColumn - 4, + add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, NewScope, Tokens, Indentation, <>); + + {error, Reason} -> + error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens) + end; + +tokenize_sigil_contents([H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens) + when ?is_sigil(H) -> + case future_elixir_interpolation:extract(Line, Column + 1, Scope, ?is_downcase(S), T, sigil_terminator(H)) of + {NewLine, NewColumn, Parts, Rest, NewScope} -> + Indentation = nil, + add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, tokens_to_binary(Parts), Rest, NewScope, Tokens, Indentation, <>); + + {error, Reason} -> + Sigil = [$~, S, H], + Message = " (for sigil ~ts starting at line ~B)", + interpolation_error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens, Message, [Sigil, Line], Line, Column, [H], [sigil_terminator(H)]) + end; + +tokenize_sigil_contents([H | _] = Original, SigilName, Line, Column, Scope, Tokens) -> + MessageString = + "\"~ts\" (column ~p, code point U+~4.16.0B). The available delimiters are: " + "//, ||, \"\", '', (), [], {}, <>", + Message = io_lib:format(MessageString, [[H], Column, H]), + ErrorColumn = Column - 1 - length(SigilName), + error({?LOC(Line, ErrorColumn), "invalid sigil delimiter: ", Message}, [$~] ++ SigilName ++ Original, Scope, Tokens); + +% Incomplete sigil. +tokenize_sigil_contents([], _SigilName, Line, Column, Scope, Tokens) -> + tokenize([], Line, Column, Scope, Tokens). + +add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, Scope, Tokens, Indentation, Delimiter) -> + TokenColumn = Column - 1 - length(SigilName), + MaybeEncoded = case SigilName of + % Single-letter sigils present no risk of atom exhaustion (limited possibilities) + [_Char] -> {ok, list_to_atom("sigil_" ++ SigilName)}; + _ -> unsafe_to_atom("sigil_" ++ SigilName, Line, TokenColumn, Scope) + end, + case MaybeEncoded of + {ok, Atom} -> + {Final, Modifiers} = collect_modifiers(Rest, []), + Token = {sigil, {Line, TokenColumn, nil}, Atom, Parts, Modifiers, Indentation, Delimiter}, + NewColumnWithModifiers = NewColumn + length(Modifiers), + tokenize(Final, NewLine, NewColumnWithModifiers, Scope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, Scope, Tokens) + end. + +%% Fail early on invalid do syntax. For example, after +%% most keywords, after comma and so on. +tokenize_keyword_terminator(DoLine, DoColumn, do, [{identifier, {Line, Column, Meta}, Atom} | T]) -> + {ok, add_token_with_eol({do, {DoLine, DoColumn, nil}}, + [{do_identifier, {Line, Column, Meta}, Atom} | T])}; +tokenize_keyword_terminator(_Line, _Column, do, [{'fn', _} | _]) -> + {error, invalid_do_with_fn_error("unexpected reserved word: "), "do"}; +tokenize_keyword_terminator(Line, Column, do, Tokens) -> + case is_valid_do(Tokens) of + true -> {ok, add_token_with_eol({do, {Line, Column, nil}}, Tokens)}; + false -> {error, invalid_do_error("unexpected reserved word: "), "do"} + end; +tokenize_keyword_terminator(Line, Column, Atom, Tokens) -> + {ok, [{Atom, {Line, Column, nil}} | Tokens]}. + +is_valid_do([{Atom, _} | _]) -> + case Atom of + ',' -> false; + ';' -> false; + 'not' -> false; + 'and' -> false; + 'or' -> false; + 'when' -> false; + 'in' -> false; + 'after' -> false; + 'else' -> false; + 'catch' -> false; + 'rescue' -> false; + _ -> true + end; +is_valid_do(_) -> + true. + +invalid_character_error(What, Char) -> + io_lib:format("invalid character \"~ts\" (code point U+~4.16.0B) in ~ts: ", [[Char], Char, What]). + +invalid_do_error(Prefix) -> + {Prefix, ". In case you wanted to write a \"do\" expression, " + "you must either use do-blocks or separate the keyword argument with comma. " + "For example, you should either write:\n\n" + " if some_condition? do\n" + " :this\n" + " else\n" + " :that\n" + " end\n\n" + "or the equivalent construct:\n\n" + " if(some_condition?, do: :this, else: :that)\n\n" + "where \"some_condition?\" is the first argument and the second argument is a keyword list.\n\n" + "You may see this error if you forget a trailing comma before the \"do\" in a \"do\" block"}. + +invalid_do_with_fn_error(Prefix) -> + {Prefix, ". Anonymous functions are written as:\n\n" + " fn pattern -> expression end\n\nPlease remove the \"do\" keyword"}. + +% TODO: Turn into an error on v2.0 +maybe_warn_too_many_of_same_char([T | _] = Token, [T | _] = _Rest, Line, Column, Scope) -> + Message = io_lib:format( + "found \"~ts\" followed by \"~ts\", please use a space between \"~ts\" and the next \"~ts\"", + [Token, [T], Token, [T]] + ), + prepend_warning(Line, Column, Message, Scope); +maybe_warn_too_many_of_same_char(_Token, _Rest, _Line, _Column, Scope) -> + Scope. + +%% TODO: Turn into an error on v2.0 +maybe_warn_for_ambiguous_bang_before_equals(Kind, Unencoded, [$= | _], Line, Column, Scope) -> + {What, Identifier} = + case Kind of + atom -> {"atom", [$: | Unencoded]}; + identifier -> {"identifier", Unencoded} + end, + + case lists:last(Identifier) of + Last when Last =:= $!; Last =:= $? -> + Msg = io_lib:format("found ~ts \"~ts\", ending with \"~ts\", followed by =. " + "It is unclear if you mean \"~ts ~ts=\" or \"~ts =\". Please add " + "a space before or after ~ts to remove the ambiguity", + [What, Identifier, [Last], lists:droplast(Identifier), [Last], Identifier, [Last]]), + prepend_warning(Line, Column, Msg, Scope); + _ -> + Scope + end; +maybe_warn_for_ambiguous_bang_before_equals(_Kind, _Atom, _Rest, _Line, _Column, Scope) -> + Scope. + +prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) -> + Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}. + +track_ascii(true, Scope) -> Scope; +track_ascii(false, Scope) -> Scope#elixir_tokenizer{ascii_identifiers_only=false}. + +maybe_unicode_lint_warnings(_Ascii=false, Tokens, Warnings) -> + 'Elixir.String.Tokenizer.Security':unicode_lint_warnings(lists:reverse(Tokens)) ++ Warnings; +maybe_unicode_lint_warnings(_Ascii=true, _Tokens, Warnings) -> + Warnings. + +error(Reason, Rest, #elixir_tokenizer{warnings=Warnings}, Tokens) -> + {error, Reason, Rest, Warnings, Tokens}. + +%% Cursor handling + +cursor_complete(Line, Column, Terminators) -> + lists:mapfoldl( + fun({Start, _, _}, AccColumn) -> + End = terminator(Start), + {{End, {Line, AccColumn, nil}}, AccColumn + length(erlang:atom_to_list(End))} + end, + Column, + Terminators + ). + +add_cursor(_Line, Column, noprune, Terminators, Tokens) -> + {Column, Terminators, Tokens}; +add_cursor(Line, Column, prune_and_cursor, Terminators, Tokens) -> + PrePrunedTokens = prune_identifier(Tokens), + {PrunedTokens, PrunedTerminators} = prune_tokens(PrePrunedTokens, [], Terminators), + CursorTokens = [ + {')', {Line, Column + 11, nil}}, + {'(', {Line, Column + 10, nil}}, + {paren_identifier, {Line, Column, nil}, '__cursor__'} + | PrunedTokens + ], + {Column + 12, PrunedTerminators, CursorTokens}. + +prune_identifier([{identifier, _, _} | Tokens]) -> Tokens; +prune_identifier(Tokens) -> Tokens. + +%%% Any terminator needs to be closed +prune_tokens([{'end', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['end' | Opener], Terminators); +prune_tokens([{')', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, [')' | Opener], Terminators); +prune_tokens([{']', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, [']' | Opener], Terminators); +prune_tokens([{'}', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['}' | Opener], Terminators); +prune_tokens([{'>>', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['>>' | Opener], Terminators); +%%% Close opened terminators +prune_tokens([{'fn', _} | Tokens], ['end' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'do', _} | Tokens], ['end' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'(', _} | Tokens], [')' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'[', _} | Tokens], [']' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'{', _} | Tokens], ['}' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'<<', _} | Tokens], ['>>' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +%%% Handle anonymous functions +prune_tokens([{'(', _}, {capture_op, _, _} | Tokens], [], [{'(', _, _} | Terminators]) -> + prune_tokens(Tokens, [], Terminators); +%%% or it is time to stop... +prune_tokens([{';', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'eol', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{',', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'fn', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'do', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'(', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'[', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'{', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'<<', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{block_identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier_safe, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier_unsafe, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{OpType, _, _} | _] = Tokens, [], Terminators) + when OpType =:= comp_op; OpType =:= at_op; OpType =:= unary_op; OpType =:= and_op; + OpType =:= or_op; OpType =:= arrow_op; OpType =:= match_op; OpType =:= in_op; + OpType =:= in_match_op; OpType =:= type_op; OpType =:= dual_op; OpType =:= mult_op; + OpType =:= power_op; OpType =:= concat_op; OpType =:= range_op; OpType =:= xor_op; + OpType =:= pipe_op; OpType =:= stab_op; OpType =:= when_op; OpType =:= assoc_op; + OpType =:= rel_op; OpType =:= ternary_op; OpType =:= capture_op; OpType =:= ellipsis_op -> + {Tokens, Terminators}; +%%% or we traverse until the end. +prune_tokens([_ | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([], [], Terminators) -> + {[], Terminators}. diff --git a/forge/src/future_elixir_tokenizer.hrl b/forge/src/future_elixir_tokenizer.hrl new file mode 100644 index 00000000..00caf183 --- /dev/null +++ b/forge/src/future_elixir_tokenizer.hrl @@ -0,0 +1,34 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_tokenizer.hrl +%% Numbers +-define(is_hex(S), (?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f))). +-define(is_bin(S), (S >= $0 andalso S =< $1)). +-define(is_octal(S), (S >= $0 andalso S =< $7)). + +%% Digits and letters +-define(is_digit(S), (S >= $0 andalso S =< $9)). +-define(is_upcase(S), (S >= $A andalso S =< $Z)). +-define(is_downcase(S), (S >= $a andalso S =< $z)). + +%% Others +-define(is_quote(S), (S =:= $" orelse S =:= $')). +-define(is_sigil(S), (S =:= $/ orelse S =:= $< orelse S =:= $" orelse S =:= $' orelse + S =:= $[ orelse S =:= $( orelse S =:= ${ orelse S =:= $|)). +-define(LOC(Line, Column), [{line, Line}, {column, Column}]). + +%% Spaces +-define(is_horizontal_space(S), (S =:= $\s orelse S =:= $\t)). +-define(is_vertical_space(S), (S =:= $\r orelse S =:= $\n)). +-define(is_space(S), (?is_horizontal_space(S) orelse ?is_vertical_space(S))). + +%% Bidirectional control +%% Retrieved from https://trojansource.codes/trojan-source.pdf +-define(bidi(C), C =:= 16#202A; + C =:= 16#202B; + C =:= 16#202D; + C =:= 16#202E; + C =:= 16#2066; + C =:= 16#2067; + C =:= 16#2068; + C =:= 16#202C; + C =:= 16#2069). + diff --git a/forge/test/lexical/ast/detection/alias_test.exs b/forge/test/lexical/ast/detection/alias_test.exs new file mode 100644 index 00000000..3dba4142 --- /dev/null +++ b/forge/test/lexical/ast/detection/alias_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.AliasTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Alias, + assertions: [[:alias, :*]] +end diff --git a/forge/test/lexical/ast/detection/bitstring_test.exs b/forge/test/lexical/ast/detection/bitstring_test.exs new file mode 100644 index 00000000..0f2ab329 --- /dev/null +++ b/forge/test/lexical/ast/detection/bitstring_test.exs @@ -0,0 +1,6 @@ +defmodule Forge.Ast.Detection.BitstringTest do + use Forge.Test.DetectionCase, + for: Forge.Ast.Detection.Bitstring, + assertions: [[:bitstring, :*]], + variations: [:match, :function_arguments, :function_body] +end diff --git a/forge/test/lexical/ast/detection/comment_test.exs b/forge/test/lexical/ast/detection/comment_test.exs new file mode 100644 index 00000000..b87b3fe2 --- /dev/null +++ b/forge/test/lexical/ast/detection/comment_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.CommentTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Comment, + assertions: [[:comment, :*]] +end diff --git a/forge/test/lexical/ast/detection/function_capture_test.exs b/forge/test/lexical/ast/detection/function_capture_test.exs new file mode 100644 index 00000000..e8acedfd --- /dev/null +++ b/forge/test/lexical/ast/detection/function_capture_test.exs @@ -0,0 +1,32 @@ +defmodule Forge.Ast.Detection.FunctionCaptureTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.FunctionCapture, + assertions: [[:function_capture, :*]], + variations: [:match, :function_body] + + test "detected if the capture is inside an unformatted function call" do + assert_detected ~q[list = Enum.map(1..10,&«Enum»)] + end + + test "detected if the capture is inside a function call after the dot" do + assert_detected ~q[list = Enum.map(1..10, &«Enum.f»)] + end + + test "detected if the capture is in the body of a for" do + assert_detected ~q[for x <- Enum.map(1..10, &«String.»)] + end + + test "is not detected if the capture is inside an unformatted function call" do + refute_detected ~q[list = Enum.map(1..10,Enum)] + end + + test "is not detected if the capture is inside a function call after the dot" do + refute_detected ~q[list = Enum.map(1..10, Enum.f)] + end + + test "is not detected if the capture is in the body of a for" do + refute_detected ~q[for x <- Enum.map(1..10, String.)] + end +end diff --git a/forge/test/lexical/ast/detection/import_test.exs b/forge/test/lexical/ast/detection/import_test.exs new file mode 100644 index 00000000..c74702b8 --- /dev/null +++ b/forge/test/lexical/ast/detection/import_test.exs @@ -0,0 +1,16 @@ +defmodule Forge.Ast.Detection.ImportTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Import, + assertions: [[:import, :*]] + + test "works on multi line" do + assert_detected ~q( + import« Some.Module, only: »[ + foo: 3, + bar: 6 + ] + ) + end +end diff --git a/forge/test/lexical/ast/detection/module_attribute_test.exs b/forge/test/lexical/ast/detection/module_attribute_test.exs new file mode 100644 index 00000000..fc501fc5 --- /dev/null +++ b/forge/test/lexical/ast/detection/module_attribute_test.exs @@ -0,0 +1,17 @@ +defmodule Forge.Ast.Detection.ModuleAttributeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.ModuleAttribute, + assertions: [ + [:module_attribute, :*], + [:callbacks, :*] + ], + skip: [ + [:doc, :*], + [:module_doc, :*], + [:spec, :*], + [:type, :*] + ], + variations: [:module] +end diff --git a/forge/test/lexical/ast/detection/pipe_test.exs b/forge/test/lexical/ast/detection/pipe_test.exs new file mode 100644 index 00000000..6902d245 --- /dev/null +++ b/forge/test/lexical/ast/detection/pipe_test.exs @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.PipeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Pipe, + assertions: [[:pipe, :*]], + variations: [:function_arguments], + skip: [[:module_attribute, :multi_line_pipe]] + + test "is false if there is no pipe in the string" do + refute_detected ~q[Enum.foo] + end +end diff --git a/forge/test/lexical/ast/detection/require_test.exs b/forge/test/lexical/ast/detection/require_test.exs new file mode 100644 index 00000000..12a58388 --- /dev/null +++ b/forge/test/lexical/ast/detection/require_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.RequireTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Require, + assertions: [[:require, :*]] +end diff --git a/forge/test/lexical/ast/detection/spec_test.exs b/forge/test/lexical/ast/detection/spec_test.exs new file mode 100644 index 00000000..c281d1bf --- /dev/null +++ b/forge/test/lexical/ast/detection/spec_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.SpecTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Spec, + assertions: [[:spec, :*]] +end diff --git a/forge/test/lexical/ast/detection/string_test.exs b/forge/test/lexical/ast/detection/string_test.exs new file mode 100644 index 00000000..12dba947 --- /dev/null +++ b/forge/test/lexical/ast/detection/string_test.exs @@ -0,0 +1,25 @@ +defmodule Forge.Ast.Detection.StringTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.String, + assertions: [[:strings, :*]], + # we skip other tests that have strings in them + skip: [ + [:doc, :*], + [:keyword, :single_line], + [:keyword, :multi_line], + [:module_doc, :*] + ], + variations: [ + :function_arguments, + :function_body, + :function_call, + :match, + :module + ] + + test "is detected if a string is keyword values" do + assert_detected ~q/def func(string: "v«alue»", atom: :value2, int: 6, float: 2.0, list: [1, 2], tuple: {3, 4}) do/ + end +end diff --git a/forge/test/lexical/ast/detection/struct_field_key_test.exs b/forge/test/lexical/ast/detection/struct_field_key_test.exs new file mode 100644 index 00000000..fd19d676 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_field_key_test.exs @@ -0,0 +1,17 @@ +defmodule Forge.Ast.Detection.StructFieldKeyTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFieldKey, + assertions: [[:struct_field_key, :*]], + skip: [ + [:struct_fields, :*], + [:struct_reference, :*], + [:struct_field_value, :*] + ], + variations: [:module] + + test "is detected if a key is partially typed" do + assert_detected ~q[%User{«fo»}] + end +end diff --git a/forge/test/lexical/ast/detection/struct_field_value_test.exs b/forge/test/lexical/ast/detection/struct_field_value_test.exs new file mode 100644 index 00000000..07b24221 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_field_value_test.exs @@ -0,0 +1,25 @@ +defmodule Forge.Ast.Detection.StructFieldValueTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFieldValue, + assertions: [[:struct_field_value, :*]], + skip: [ + [:struct_fields, :*], + [:struct_reference, :*], + [:struct_field_key, :*] + ], + variations: [:module] + + test "is detected directly after the colon" do + assert_detected ~q[%User{foo: «»}] + end + + test "is not detected if the cursor is a multiple line definition in a key position" do + assert_detected ~q[ + %User{ + foo: «1,» + } + ] + end +end diff --git a/forge/test/lexical/ast/detection/struct_fields_test.exs b/forge/test/lexical/ast/detection/struct_fields_test.exs new file mode 100644 index 00000000..477144cc --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_fields_test.exs @@ -0,0 +1,33 @@ +defmodule Forge.Ast.Detection.StructFieldsTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFields, + assertions: [[:struct_fields, :*]], + variations: [:match, :function_body, :function_arguments, :module], + skip: [ + [:struct_reference, :*], + [:struct_field_value, :*], + [:struct_field_key, :*] + ] + + test "is true if the cursor is in current module arguments" do + assert_detected ~q[%__MODULE__{«»}] + end + + test "is true even if the value of a struct key is a tuple" do + assert_detected ~q[%User{«favorite_numbers: {3}»}] + end + + test "is true even if the cursor is at a nested struct" do + assert_detected ~q[%User{«address: %Address{}»] + end + + test "is detected if it spans multiple lines" do + assert_detected ~q[ + %User{ + «name: "John", + »} + ] + end +end diff --git a/forge/test/lexical/ast/detection/struct_reference_test.exs b/forge/test/lexical/ast/detection/struct_reference_test.exs new file mode 100644 index 00000000..90232d47 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_reference_test.exs @@ -0,0 +1,45 @@ +defmodule Forge.Ast.Detection.StructReferenceTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructReference, + assertions: [[:struct_reference, :*]], + skip: [[:struct_fields, :*], [:struct_field_value, :*], [:struct_field_key, :*]], + variations: [:match, :function_arguments] + + test "is detected if a module reference starts in function arguments" do + assert_detected ~q[def my_function(%_«»)] + end + + test "is detected if a module reference start in a t type spec" do + assert_detected ~q[@type t :: %_«»] + end + + test "is detected if the reference is for %__MOD in a function definition " do + assert_detected ~q[def my_fn(%_«_MOD»] + end + + test "is detected if the reference is on the right side of a match" do + assert_detected ~q[foo = %U«se»] + end + + test "is detected if the reference is on the left side of a match" do + assert_detected ~q[ %U«se» = foo] + end + + test "is detected if the reference is for %__} " do + assert_detected ~q[%__] + end + + test "is not detected if the reference is for %__MOC in a function definition" do + refute_detected ~q[def my_fn(%__MOC)] + end + + test "is detected if module reference starts with %" do + assert_detected ~q[def something(my_thing, %S«truct»{})] + end + + test "is not detected if a module reference lacks a %" do + refute_detected ~q[def my_function(__)] + end +end diff --git a/forge/test/lexical/ast/detection/type_test.exs b/forge/test/lexical/ast/detection/type_test.exs new file mode 100644 index 00000000..c8403bf8 --- /dev/null +++ b/forge/test/lexical/ast/detection/type_test.exs @@ -0,0 +1,18 @@ +defmodule Forge.Ast.Detection.TypeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Type, + assertions: [[:type, :*]] + + test "is not detected if you're in a variable named type" do + refute_detected ~q[type = 3] + end + + test "is not detected right after the type ends" do + refute_detected ~q[ + @type« my_type :: atom» + + ] + end +end diff --git a/forge/test/lexical/ast/detection/use_test.exs b/forge/test/lexical/ast/detection/use_test.exs new file mode 100644 index 00000000..b7685841 --- /dev/null +++ b/forge/test/lexical/ast/detection/use_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.UseTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Use, + assertions: [[:use, :*]] +end diff --git a/forge/test/lexical/ast/env_test.exs b/forge/test/lexical/ast/env_test.exs new file mode 100644 index 00000000..9e12ba0b --- /dev/null +++ b/forge/test/lexical/ast/env_test.exs @@ -0,0 +1,236 @@ +defmodule Forge.Ast.EnvTest do + use ExUnit.Case, async: true + + alias Forge.Ast + + import Forge.Ast.Env + import Forge.Test.CursorSupport + import Forge.Test.Fixtures + + def new_env(text, opts \\ []) do + opts = Keyword.merge([as: :document], opts) + project = project() + {position, document} = pop_cursor(text, opts) + analysis = Ast.analyze(document) + {:ok, env} = new(project, analysis, position) + env + end + + describe "prefix_tokens/2" do + test "works with bitstring specifiers" do + env = new_env("< new_env() + |> prefix_tokens(1) + + assert [{:float, 27.88, _}] = tokens + end + + test "works with strings" do + tokens = + ~s("hello") + |> new_env() + |> prefix_tokens(1) + + assert [{:string, "hello", _}] = tokens + end + + test "works with interpolated strings" do + tokens = + ~S("hello#{a}") + |> new_env() + |> prefix_tokens(1) + + assert [{:interpolated_string, interpolations, {1, 1}}] = tokens + + assert interpolations == [ + {:literal, "hello", {{1, 1}, {1, 6}}}, + {:interpolation, [{:identifier, {1, 9, ~c"a"}, :a}], {{1, 9}, {1, 10}}} + ] + end + + test "works with maps with atom keys" do + tokens = + "%{a: 3}" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:curly, :"}", _}, + {:int, 3, _}, + {:kw_identifier, ~c"a", _}, + {:curly, :"{", _}, + {:map_new, :%{}, _} + ] = tokens + end + + test "works with maps with string keys" do + tokens = + ~s(%{"a" => 3}) + |> new_env() + |> prefix_tokens(8) + + assert [ + {:curly, :"}", _}, + {:int, 3, _}, + {:assoc_op, nil, _}, + {:string, "a", _}, + {:curly, :"{", _}, + {:map_new, :%{}, _} + ] = tokens + end + + test "works with pattern matches" do + tokens = + "my_var = 3 + 5" + |> new_env() + |> prefix_tokens(3) + + assert [ + {:int, 5, _}, + {:operator, :+, _}, + {:int, 3, _} + ] = tokens + end + + test "works with remote function calls" do + tokens = + "Enum.map|" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:identifier, ~c"map", _}, + {:operator, :., _}, + {:alias, ~c"Enum", _} + ] = tokens + end + + test "works with local function calls" do + tokens = + "foo = local(|" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:paren, :"(", _}, + {:paren_identifier, ~c"local", _}, + {:match_op, nil, _}, + {:identifier, ~c"foo", _} + ] = tokens + end + + test "consumes as many tokens as it can" do + tokens = + "String.tri|" + |> new_env() + |> prefix_tokens(900) + + assert [ + {:identifier, ~c"tri", _}, + {:operator, :., _}, + {:alias, ~c"String", _} + ] = tokens + end + + test "works with macros" do + tokens = + "defmacro MyModule do" + |> new_env() + |> prefix_tokens(3) + + assert [ + {:operator, :do, _}, + {:alias, ~c"MyModule", _}, + {:identifier, ~c"defmacro", _} + ] = tokens + end + + test "works with lists of integers" do + tokens = + "x = [1, 2, 3]" + |> new_env() + |> prefix_tokens(7) + + assert [ + {:operator, :"]", _}, + {:int, 3, _}, + {:comma, :",", _}, + {:int, 2, _}, + {:comma, :",", _}, + {:int, 1, _}, + {:operator, :"[", _} + ] = tokens + end + end + + describe "in_context?/2" do + test "can detect module attributes" do + env = new_env("@my_attr 3") + + assert in_context?(env, {:module_attribute, :my_attr}) + refute in_context?(env, {:module_attribute, :other}) + end + + test "can detect behaviours" do + env = new_env("@behaviour Modul|e") + + assert in_context?(env, :behaviour) + end + + test "can detect behaviour implementations" do + env = new_env("@impl GenServer|") + + assert in_context?(env, :impl) + end + + test "can detect docstrings " do + env = new_env("@doc false|") + assert in_context?(env, :doc) + + env = new_env(~S[@doc "hi"]) + assert in_context?(env, :doc) + + env = new_env(~S[@doc """ + Multi - line + """| + ]) + assert in_context?(env, :doc) + end + + test "can detect moduledocs " do + env = new_env("@moduledoc false|") + assert in_context?(env, :moduledoc) + + env = new_env(~S[@moduledoc "hi"]) + assert in_context?(env, :moduledoc) + + env = new_env(~S[@moduledoc """ + Multi - line + """| + ]) + assert in_context?(env, :moduledoc) + end + + test "can detect callbacks" do + env = new_env("@callback do_stuff|(integer(), map()) :: any()") + assert in_context?(env, :callback) + end + + test "can detect macro callbacks" do + env = new_env("@macrocallback write_code(integer(), map(|)) :: any()") + assert in_context?(env, :macrocallback) + end + + test "can detect strings" do + env = new_env(~s/var = "in |a string"/) + assert in_context?(env, :string) + end + end +end diff --git a/forge/test/lexical/ast/module_test.exs b/forge/test/lexical/ast/module_test.exs new file mode 100644 index 00000000..492eb388 --- /dev/null +++ b/forge/test/lexical/ast/module_test.exs @@ -0,0 +1,26 @@ +defmodule Forge.Ast.ModuleTest do + import Forge.Ast.Module + use ExUnit.Case, async: true + + describe "safe_split/2" do + test "splits elixir modules into binaries by default" do + assert {:elixir, ~w(Forge Document Store)} == safe_split(Forge.Document.Store) + end + + test "splits elixir modules into binaries" do + assert {:elixir, ~w(Forge Document Store)} == + safe_split(Forge.Document.Store, as: :binaries) + end + + test "splits elixir modules into atoms" do + assert {:elixir, ~w(Forge Document Store)a} == + safe_split(Forge.Document.Store, as: :atoms) + end + + test "splits erlang modules" do + assert {:erlang, ["ets"]} = safe_split(:ets) + assert {:erlang, ["ets"]} = safe_split(:ets, as: :binaries) + assert {:erlang, [:ets]} = safe_split(:ets, as: :atoms) + end + end +end diff --git a/forge/test/lexical/ast/tokens_test.exs b/forge/test/lexical/ast/tokens_test.exs new file mode 100644 index 00000000..c3f71e46 --- /dev/null +++ b/forge/test/lexical/ast/tokens_test.exs @@ -0,0 +1,51 @@ +defmodule Forge.Ast.TokensTest do + alias Forge.Ast.Tokens + + import Forge.Test.CodeSigil + import Forge.Test.CursorSupport + + use ExUnit.Case, async: true + + describe "prefix_stream/2" do + test "works as intended" do + text = ~q[ + defmodule Foo do + def bar do + | + end + end + ] + + {position, document} = pop_cursor(text, as: :document) + + tokens = Tokens.prefix_stream(document, position) + + assert Enum.to_list(tokens) == [ + {:eol, ~c"\n", []}, + {:operator, :do, {2, 11}}, + {:do_identifier, ~c"bar", {2, 7}}, + {:identifier, ~c"def", {2, 3}}, + {:eol, ~c"\n", []}, + {:operator, :do, {1, 15}}, + {:alias, ~c"Foo", {1, 11}}, + {:identifier, ~c"defmodule", {1, 1}} + ] + end + + test "returns nothing when cursor is at start" do + text = ~q[ + |defmodule Foo do + def bar do + :bar + end + end + ] + + {position, document} = pop_cursor(text, as: :document) + + tokens = Tokens.prefix_stream(document, position) + + assert Enum.to_list(tokens) == [] + end + end +end diff --git a/forge/test/lexical/ast_test.exs b/forge/test/lexical/ast_test.exs new file mode 100644 index 00000000..16796b65 --- /dev/null +++ b/forge/test/lexical/ast_test.exs @@ -0,0 +1,347 @@ +defmodule Forge.AstTest do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Position + alias Sourceror.Zipper + + import Forge.Test.CodeSigil + import Forge.Test.CursorSupport + import Forge.Test.PositionSupport + import Forge.Test.RangeSupport + + use ExUnit.Case, async: true + + describe "cursor_path/2" do + defp cursor_path(text) do + {position, document} = pop_cursor(text, as: :document) + Ast.cursor_path(document, position) + end + + test "contains the parent AST" do + text = ~q[ + defmodule Foo do + def bar do + | + end + end + ] + + path = cursor_path(text) + + assert Enum.any?(path, &match?({:def, _, _}, &1)) + assert Enum.any?(path, &match?({:defmodule, _, _}, &1)) + end + + test "returns cursor ast when is not in a container" do + text = ~q[ + | + defmodule Foo do + end + ] + + path = cursor_path(text) + assert path == [{:__cursor__, [closing: [line: 1, column: 12], line: 1, column: 1], []}] + end + + test "returns [] when can't parse the AST" do + text = ~q[ + foo(bar do baz, [bat| + ] + + path = cursor_path(text) + assert path == [] + end + end + + describe "path_at/2" do + defp path_at(text) do + {position, document} = pop_cursor(text, as: :document) + Ast.path_at(document, position) + end + + defp end_location({_, metadata, _}), do: end_location(metadata) + + defp end_location(metadata) when is_list(metadata) do + case metadata do + [line: line, column: column] -> + {line, column} + + metadata -> + [end_line: line, end_column: column] = Keyword.take(metadata, [:end_line, :end_column]) + + {line, column} + end + end + + test "returns an error if the cursor cannot be found in any node" do + code = ~q[ + | + defmodule Foo do + end + ] + + assert {:error, :not_found} = path_at(code) + end + + test "returns an error if the AST cannot be parsed" do + code = ~q[ + defmodule |Foo do + ] + + assert {:error, {metadata, "missing terminator: end" <> _, ""}} = path_at(code) + assert end_location(metadata) == {2, 1} + end + + test "returns a path to the innermost leaf at position" do + code = ~q[ + defmodule Foo do + def bar do + %{foo: |:ok} + end + end + ] + + assert {:ok, [{:__block__, _, [:ok]} | _]} = path_at(code) + end + + test "returns a path to the innermost branch at position" do + code = ~q[ + defmodule Foo do + | + end + ] + + assert {:ok, [{:defmodule, _, _}]} = path_at(code) + end + + test "returns a path containing all ancestors" do + code = ~q[ + defmodule Foo do + def |bar do + :ok + end + end + ] + + assert {:ok, + [ + {:bar, _, nil}, + {:def, _, _}, + {_, _}, + [{_, _}], + {:defmodule, _, _} + ]} = path_at(code) + end + + test "returns a path to an outer struct node" do + code = ~q[ + defmodule Foo do + |%MyStruct{} + end + ] + + assert {:ok, [{:%, _, _} | _]} = path_at(code) + end + end + + describe "traverse_line" do + setup do + text = ~q[ + line = 1 + line = 2 + line = 3 + line = 4 + "" + ]t + + document = Document.new("file:///file.ex", text, 1) + + {:ok, document: document} + end + + defp underscore_variable(%Zipper{node: {var_name, meta, nil}} = zipper) do + Zipper.replace(zipper, {:"_#{var_name}", meta, nil}) + end + + defp underscore_variable(zipper), do: zipper + + defp underscore_variable(%Zipper{node: {_var_name, _meta, nil}} = zipper, acc) do + zipper = underscore_variable(zipper) + {zipper, acc + 1} + end + + defp underscore_variable(zipper, acc), do: {zipper, acc} + + defp modify({:ok, zipper}) do + %Zipper{node: ast} = Zipper.top(zipper) + Sourceror.to_string(ast) + end + + defp modify({:ok, zipper, acc}) do + {modify({:ok, zipper}), acc} + end + + test "/3 should only affect the specified line", %{document: doc} do + converted = + doc + |> Ast.traverse_line(2, &underscore_variable/1) + |> modify() + + assert converted =~ "_line = 2" + assert converted =~ "line = 1" + assert converted =~ "line = 3" + assert converted =~ "line = 4" + end + + test "/4 should only affect the specified line, and keeps an accumulator", %{document: doc} do + {converted, acc} = + doc + |> Ast.traverse_line(2, 0, &underscore_variable/2) + |> modify() + + assert acc == 1 + assert converted =~ "_line = 2" + refute converted =~ "_line = 1" + refute converted =~ "_line = 3" + end + end + + describe "contains_position?/2 single line node" do + setup do + {range, code} = pop_range(~q| + [ + «single_line_call(1, 2, 3)» + ] + |) + + [single_line_ast] = ast(code) + + {:ok, [ast: single_line_ast, range: range]} + end + + test "at the bounds", %{ast: ast, range: range} do + assert Ast.contains_position?(ast, range.start) + assert Ast.contains_position?(ast, range.end) + end + + test "within the node", %{ast: ast, range: range} do + position = %Position{range.start | character: range.start.character + 1} + assert Ast.contains_position?(ast, position) + end + + test "outside the bounds", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + %Position{line: end_line, character: end_col} = range.end + + refute Ast.contains_position?(ast, position(start_line, start_col - 1)) + refute Ast.contains_position?(ast, position(start_line - 1, start_col)) + refute Ast.contains_position?(ast, position(end_line, end_col + 1)) + refute Ast.contains_position?(ast, position(end_line + 1, end_col)) + end + end + + describe "contains_position?/2 multi line node" do + setup do + {range, code} = pop_range(~q| + [ + «multi_line_call( + 1, 2, 3 + )» + ] + |) + + [three_line_ast] = ast(code) + + {:ok, [ast: three_line_ast, range: range]} + end + + test "at the bounds", %{ast: ast, range: range} do + assert Ast.contains_position?(ast, range.start) + assert Ast.contains_position?(ast, range.end) + end + + test "on the first line", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + + assert Ast.contains_position?(ast, position(start_line, start_col + 1)) + refute Ast.contains_position?(ast, position(start_line, start_col - 1)) + end + + test "on the last line", %{ast: ast, range: range} do + %Position{line: end_line, character: end_col} = range.end + + assert Ast.contains_position?(ast, position(end_line, end_col - 1)) + refute Ast.contains_position?(ast, position(end_line, end_col + 1)) + end + + test "within the lines", %{ast: ast, range: range} do + %Position{line: start_line} = range.start + + assert Ast.contains_position?(ast, position(start_line + 1, 1)) + assert Ast.contains_position?(ast, position(start_line + 1, 1_000)) + end + + test "outside the lines", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + %Position{line: end_line, character: end_col} = range.end + + refute Ast.contains_position?(ast, position(start_line - 1, start_col)) + refute Ast.contains_position?(ast, position(end_line + 1, end_col)) + end + end + + describe "analyze/1" do + test "creates an analysis from a document with valid ast" do + code = ~q[ + defmodule Valid do + end + ] + + assert %Analysis{} = analysis = analyze(code) + assert {:defmodule, _, _} = analysis.ast + end + + test "creates an analysis from a document with invalid ast" do + code = ~q[ + defmodule Invalid do + ] + + assert %Analysis{} = analysis = analyze(code) + refute analysis.ast + assert {:error, _} = analysis.parse_error + end + + test "creates an analysis from a document with incomplete `as` section" do + code = ~q[ + defmodule Invalid do + alias Foo, a + end + ] + + assert %Analysis{} = analysis = analyze(code) + assert {:defmodule, _, _} = analysis.ast + end + + test "handles incomplete imports" do + code = ~q[ + defmodule Invalid do + import Other, only: :m + end + ] + assert %Analysis{} = analyze(code) + end + end + + defp ast(s) do + case Ast.from(s) do + {:ok, {:__block__, _, [node]}, _comments} -> node + {:ok, node, _comments} -> node + end + end + + defp analyze(code) when is_binary(code) do + document = Document.new("file:///file.ex", code, 0) + Ast.analyze(document) + end +end diff --git a/forge/test/lexical/code_unit_test.exs b/forge/test/lexical/code_unit_test.exs new file mode 100644 index 00000000..d278b3dc --- /dev/null +++ b/forge/test/lexical/code_unit_test.exs @@ -0,0 +1,77 @@ +defmodule Forge.CodeUnitTest do + alias Forge.CodeUnit + + use ExUnit.Case + + import CodeUnit + + describe "utf8_position_to_utf16_offset/2" do + test "handles single-byte characters" do + s = "do" + assert 0 == utf8_position_to_utf16_offset(s, 0) + assert 1 == utf8_position_to_utf16_offset(s, 1) + assert 2 == utf8_position_to_utf16_offset(s, 2) + assert 2 == utf8_position_to_utf16_offset(s, 3) + assert 2 == utf8_position_to_utf16_offset(s, 4) + end + + test "caps offsets at the end of the string and beyond" do + line = "🎸" + assert 2 == utf8_position_to_utf16_offset(line, 1) + assert 2 == utf8_position_to_utf16_offset(line, 2) + assert 2 == utf8_position_to_utf16_offset(line, 3) + assert 2 == utf8_position_to_utf16_offset(line, 4) + end + + test "handles multi-byte characters properly" do + # guitar is 2 code units in utf16 but 4 in utf8 + line = "b🎸abc" + assert 0 == utf8_position_to_utf16_offset(line, 0) + assert 1 == utf8_position_to_utf16_offset(line, 1) + assert 3 == utf8_position_to_utf16_offset(line, 2) + assert 4 == utf8_position_to_utf16_offset(line, 3) + assert 5 == utf8_position_to_utf16_offset(line, 4) + assert 6 == utf8_position_to_utf16_offset(line, 5) + assert 6 == utf8_position_to_utf16_offset(line, 6) + end + end + + describe "utf16_offset_to_utf8_offset" do + test "with a multi-byte character" do + line = "🏳️‍🌈" + + code_unit_count = count_utf8_code_units(line) + + assert utf16_offset_to_utf8_offset(line, 0) == {:ok, 1} + assert utf16_offset_to_utf8_offset(line, 1) == {:error, :misaligned} + assert utf16_offset_to_utf8_offset(line, 2) == {:ok, 5} + assert utf16_offset_to_utf8_offset(line, 3) == {:ok, 8} + assert utf16_offset_to_utf8_offset(line, 4) == {:ok, 11} + assert utf16_offset_to_utf8_offset(line, 5) == {:error, :misaligned} + assert utf16_offset_to_utf8_offset(line, 6) == {:ok, code_unit_count + 1} + end + + test "after a unicode character" do + line = " {\"🎸\", \"ok\"}" + + assert utf16_offset_to_utf8_offset(line, 0) == {:ok, 1} + assert utf16_offset_to_utf8_offset(line, 1) == {:ok, 2} + assert utf16_offset_to_utf8_offset(line, 4) == {:ok, 5} + assert utf16_offset_to_utf8_offset(line, 5) == {:ok, 6} + assert utf16_offset_to_utf8_offset(line, 6) == {:ok, 7} + assert utf16_offset_to_utf8_offset(line, 7) == {:error, :misaligned} + # after the guitar character + assert utf16_offset_to_utf8_offset(line, 8) == {:ok, 11} + assert utf16_offset_to_utf8_offset(line, 9) == {:ok, 12} + assert utf16_offset_to_utf8_offset(line, 10) == {:ok, 13} + assert utf16_offset_to_utf8_offset(line, 11) == {:ok, 14} + assert utf16_offset_to_utf8_offset(line, 12) == {:ok, 15} + assert utf16_offset_to_utf8_offset(line, 13) == {:ok, 16} + assert utf16_offset_to_utf8_offset(line, 17) == {:ok, 20} + end + end + + defp count_utf8_code_units(utf8_string) do + byte_size(utf8_string) + end +end diff --git a/forge/test/lexical/math_test.exs b/forge/test/lexical/math_test.exs new file mode 100644 index 00000000..1eb61a27 --- /dev/null +++ b/forge/test/lexical/math_test.exs @@ -0,0 +1,40 @@ +defmodule Forge.MathTest do + alias Forge.Math + + use ExUnit.Case, async: true + use ExUnitProperties + + describe "clamp/3" do + test "returns low when value is less than low" do + assert Math.clamp(-5, 0, 5) == 0 + end + + test "returns value when value is between low and high" do + assert Math.clamp(3, 0, 5) == 3 + end + + test "returns high when value is greater than high" do + assert Math.clamp(6, 0, 5) == 5 + end + end + + def low_mid_high(unique_list) do + [low | rest] = Enum.sort(unique_list) + + mid_index = trunc(length(rest) / 2) + mid = Enum.at(rest, mid_index) + high = List.last(rest) + [low, mid, high] + end + + property "clamp works with all integers" do + check all( + ints <- uniq_list_of(integer(-100_000..100_000), min_length: 5, max_length: 20), + [low, mid, high] = low_mid_high(ints) + ) do + assert Math.clamp(mid, low, high) == mid + assert Math.clamp(low, mid, high) == mid + assert Math.clamp(high, low, mid) == mid + end + end +end diff --git a/forge/test/lexical/vm/versions_test.exs b/forge/test/lexical/vm/versions_test.exs new file mode 100644 index 00000000..a06d2da8 --- /dev/null +++ b/forge/test/lexical/vm/versions_test.exs @@ -0,0 +1,115 @@ +defmodule Forge.VM.VersionTest do + alias Forge.VM.Versions + use ExUnit.Case + use Patch + import Versions + + test "it gets the current version" do + assert current().elixir == System.version() + end + + test "it gets the current erlang version" do + patch(Versions, :erlang_version, fn -> "25.3.2.1" end) + assert current().erlang == "25.3.2.1" + end + + test "it reads the versions in a directory" do + patch(Versions, :read_file, fn "/foo/bar/baz/" <> file -> + if String.ends_with?(file, ".erlang") do + {:ok, "25.3.2.2"} + else + {:ok, "14.5.2"} + end + end) + + assert {:ok, tags} = read("/foo/bar/baz") + + assert tags.elixir == "14.5.2" + assert tags.erlang == "25.3.2.2" + end + + test "it writes the versions" do + patch(Versions, :erlang_version, "25.3.2.1") + patch(Versions, :write_file!, :ok) + + elixir_version = System.version() + + assert write("/foo/bar/baz") + assert_called(Versions.write_file!("/foo/bar/baz/.erlang", "25.3.2.1")) + assert_called(Versions.write_file!("/foo/bar/baz/.elixir", ^elixir_version)) + end + + def patch_system_versions(elixir, erlang) do + patch(Versions, :elixir_version, elixir) + patch(Versions, :erlang_version, erlang) + end + + def patch_tagged_versions(elixir, erlang) do + patch(Versions, :read_file, fn file -> + if String.ends_with?(file, ".elixir") do + {:ok, elixir} + else + {:ok, erlang} + end + end) + end + + def with_exposed_normalize(_) do + expose(Versions, normalize: 1) + :ok + end + + describe "normalize/1" do + setup [:with_exposed_normalize] + + test "fixes a two-element version" do + assert "25.0.0" == private(Versions.normalize("25.0")) + end + + test "keeps three-element versions the same" do + assert "25.3.2" == private(Versions.normalize("25.3.2")) + end + + test "truncates versions with more than three elements" do + assert "25.3.2" == private(Versions.normalize("25.3.2.2")) + + # I can't imagine they'd do this, but, you know, belt and suspenders + assert "25.3.2" == private(Versions.normalize("25.3.2.1.2")) + assert "25.3.2" == private(Versions.normalize("25.3.2.4.2.3")) + end + end + + test "an untagged directory is not compatible" do + refute compatible?(System.tmp_dir!()) + end + + describe "compatible?/1" do + test "lower major versions of erlang are compatible with later major versions" do + patch_system_versions("1.14.5", "26.0") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + + test "higher major versions are not compatible with lower major versions" do + patch_system_versions("1.14.5", "25.0") + patch_tagged_versions("1.14.5", "26.0") + + refute compatible?("/foo/bar/baz") + end + + test "the same versions are compatible with each other" do + patch_system_versions("1.14.5", "25.3.3") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + + test "higher minor versions are compatible" do + patch_system_versions("1.14.5", "25.3.0") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + end +end diff --git a/forge/test/support/lexical/test/detection_case.ex b/forge/test/support/lexical/test/detection_case.ex new file mode 100644 index 00000000..e8551a7c --- /dev/null +++ b/forge/test/support/lexical/test/detection_case.ex @@ -0,0 +1,337 @@ +defmodule Forge.Test.DetectionCase do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Test.DetectionCase.Suite + alias Forge.Test.Variations + + import Forge.Test.RangeSupport + import ExUnit.Assertions + use ExUnit.CaseTemplate + + using(args) do + context = Keyword.fetch!(args, :for) + assertion_query = Keyword.fetch!(args, :assertions) + variations = Keyword.get(args, :variations, []) ++ [:nothing] + # sometimes one type of thing can be found in another (for example, a struct reference is + # found in a struct field case), so we don't want to build a refutation + # for that thing. `skip` allows us to remove certain cases from refutes. + skip = Keyword.get(args, :skip, []) + + {assertions, refutes} = Enum.split_with(Suite.get(), &matches?(&1, assertion_query)) + + if Enum.empty?(assertions) do + query = + assertion_query + |> Macro.expand(__CALLER__) + |> Macro.to_string() + + flunk("No assertions matched the query #{query}") + end + + refutes = Enum.reject(refutes, &matches?(&1, skip)) + assertions = build_assertion_cases(context, assertions, variations) + refutations = build_refutation_cases(context, refutes, variations) + + quote location: :keep do + @context unquote(context) + alias Forge.Test.DetectionCase + + import Forge.Test.CodeSigil + + import unquote(__MODULE__), + only: [ + assert_detected: 2, + refute_detected: 2 + ] + + unquote_splicing(assertions) + unquote_splicing(refutations) + + def assert_detected(code) do + assert_detected @context, code + end + + def refute_detected(code) do + refute_detected @context, code + end + end + end + + def refute_detected(context, code) do + document = Document.new("file:///file.ex", code, 1) + analysis = Ast.analyze(document) + + for position <- position_stream(document) do + try do + refute context.detected?(analysis, position) + rescue + e in ExUnit.AssertionError -> + flunk(error_for(document, position, context, e)) + end + end + end + + def assert_detected(context, code) do + {ranges, code} = pop_all_ranges(code) + + document = Document.new("file:///file.ex", code, 1) + analysis = Ast.analyze(document) + assert_contexts_in_range(analysis, context, ranges) + end + + defp includes?(%Range{} = range, %Position{} = position) do + cond do + range.start.line == position.line and range.end.line == position.line -> + position.character >= range.start.character and + position.character <= range.end.character + + range.start.line == position.line -> + position.character >= range.start.character + + range.end.line == position.line -> + position.character <= range.end.character + + true -> + position.line > range.start.line and position.line < range.end.line + end + end + + defp matches?({type, _}, assertions) do + Enum.any?(assertions, &wildcard_matches?(&1, type)) + end + + defp wildcard_matches?(wildcard, type) do + wildcard + |> Enum.zip(type) + |> Enum.reduce_while(true, fn + {same, same}, _ -> + {:cont, true} + + {:*, _}, _ -> + {:halt, true} + + {_, _}, _ -> + {:halt, false} + end) + end + + defp build_assertion_cases(context, assertions, variations) do + for {type, test} <- assertions, + variation <- variations do + build_assertion_variation(context, type, variation, test) + end + end + + defp build_assertion_variation(context, type, variation, test) do + assertion_text = Variations.wrap_with(variation, test) + test_name = type_to_name(type, variation) + + quote generated: true do + test unquote(test_name) do + assert_detected unquote(context), unquote(assertion_text) + end + end + end + + defp assert_contexts_in_range(%Analysis{} = analysis, context, ranges) do + positions_by_range = + analysis.document + |> position_stream() + |> Enum.group_by(fn position -> Enum.find(ranges, &includes?(&1, position)) end) + + for {range, positions} <- positions_by_range, + position <- positions do + try do + if range do + assert context.detected?(analysis, position) + else + refute context.detected?(analysis, position) + end + rescue + e in ExUnit.AssertionError -> + analysis.document + |> error_for(position, context, e) + |> ExUnit.Assertions.flunk() + end + end + end + + defp build_refutation_cases(context, assertions, variations) do + for {type, test} <- assertions, + variation <- variations do + build_refutation_variation(context, type, variation, test) + end + end + + defp build_refutation_variation(context, type, variation, test) do + {_range, refutation_text} = + variation + |> Variations.wrap_with(test) + |> pop_range() + + test_name = type_to_name(type, variation) + + quote generated: true do + test unquote(test_name) do + refute_detected unquote(context), unquote(refutation_text) + end + end + end + + defp error_for(%Document{} = doc, %Position{} = pos, context, assertion_error) do + message = message_for_assertion_type(assertion_error, context, pos) + + test_text = + doc + |> insert_cursor(pos) + |> Document.to_string() + + [ + IO.ANSI.red(), + message, + IO.ANSI.reset(), + "\n", + "document:", + "\n\n", + test_text, + "\n\n" + ] + |> IO.ANSI.format() + |> IO.iodata_to_binary() + end + + defp message_for_assertion_type(%ExUnit.AssertionError{} = error, context, position) do + context = context |> Module.split() |> List.last() + + case assertion_type(error.expr) do + :assert -> + "The cursor at {#{position.line}, #{position.character}} should have been detected as a #{context}, but it wasn't." + + :refute -> + "The cursor at {#{position.line}, #{position.character}} was detected as #{context}, but it shouldn't have been" + end + end + + defp assertion_type({type, _, _}) do + case Atom.to_string(type) do + "assert" <> _ -> :assert + _ -> :refute + end + end + + defp insert_cursor(%Document{} = document, %Position{} = position) do + cursor = + [ + IO.ANSI.bright(), + IO.ANSI.light_red(), + "|", + IO.ANSI.reset() + ] + |> IO.ANSI.format() + |> IO.iodata_to_binary() + + range = Range.new(position, position) + edit = Document.Edit.new(cursor, range) + {:ok, document} = Document.apply_content_changes(document, document.version + 1, [edit]) + + document + end + + defp type_to_name(type, variation) do + words = fn atom -> + atom + |> Atom.to_string() + |> String.split("_") + |> Enum.join(" ") + end + + base_name = Enum.map_join(type, ", ", words) + + variation = + if variation == :nothing do + "" + else + "(inside #{words.(variation)})" + end + + "#{base_name} #{variation}" + end + + def position_stream(%Document{} = document) do + line_count = Document.size(document) + + init_fn = fn -> + 1 + end + + next_fn = fn + line_number when line_number <= line_count -> + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> + token_positions = + document + |> Tokens.prefix_stream( + Position.new(document, line_number, String.length(line_text) + 1) + ) + |> Stream.filter(fn + {_token, _, {^line_number, _character}} -> + true + + _ -> + false + end) + |> Enum.reduce( + [], + fn + {:string, contents, position}, acc -> + string_literal_positions(document, contents, position) ++ acc + + {:interpolated_string, interpolations, _}, acc -> + interpolation_positions(document, interpolations) ++ acc + + {_token_type, _token, {_line, character}}, acc -> + pos = Position.new(document, line_number, character) + [pos | acc] + end + ) + + {token_positions, line_number + 1} + end + + _ -> + {:halt, :ok} + end + + finalize = fn _ -> :ok end + + Stream.resource(init_fn, next_fn, finalize) + end + + defp string_literal_positions(%Document{} = document, string_contents, {line, column}) do + # add two for the quotes + string_length = String.length(string_contents) + 2 + before_pos = Position.new(document, line, column + 1) + after_pos = Position.new(document, line, column + string_length) + + [after_pos, before_pos] + end + + defp interpolation_positions(%Document{} = document, interpolations) do + interpolations + |> Enum.flat_map(fn {_, _, {{start_line, start_col}, {_end_line, end_col}}} -> + in_between_positions = + Enum.map(start_col..end_col, fn column -> + Position.new(document, start_line, column) + end) + + start_pos = Position.new(document, start_line, start_col) + + [start_pos | in_between_positions] + end) + |> Enum.uniq() + end +end diff --git a/forge/test/support/lexical/test/detection_case/suite.ex b/forge/test/support/lexical/test/detection_case/suite.ex new file mode 100644 index 00000000..7e531999 --- /dev/null +++ b/forge/test/support/lexical/test/detection_case/suite.ex @@ -0,0 +1,309 @@ +defmodule Forge.Test.DetectionCase.Suite do + @moduledoc """ + Defines a test suite for the detection case tests. + """ + import Forge.Test.CodeSigil + + @doc """ + Returns a list of tuples where: + + The first element is the path of the suite. Test cases can select and + skip parts of the suite based on the path + + The second element is the code, defined via the code sigil. The code can contain + multiple ranges, defined with the `«` and `»` characters. Ranges define the areas + of the code that contain the part of the code that is expected to be detected by + the recognizer with the same name as the first element of the list. + """ + + def suite do + [ + alias: [ + single: ~q(alias F«oo»), + multiple: ~q( + alias M«yModule.{ + First, + Second, + Third» + } + ), + as: ~q[alias M«yModule.Submodule, as: Alias»], + # Note: we need the token after the alias for the test, since + # we can't place a range on an empty space + multiple_on_one_line: ~q[alias F«oo.{Bar, Baz, Quux»};3 ] + ], + bitstring: [ + one_line: ~q[<<«foo::integer, bar::binary»>>], + multi_line: ~q[ + <<«foo::integer, + bar::binary-size(6) + »>> + ] + ], + callbacks: [ + callback: [ + zero_arg: "@«callback my_cb() :: boolean()»", + one_arg: "@«callback my_cb(foo :: integer) :: String.t()»", + multiple_args: "@«callback my_cb(foo :: integer, bar:: String.t()) :: [pos_integer()]»", + multiple_line: """ + @«callback my_cb( + foo :: String.t(), + bar :: pos_integer()) :: pos_integer()» + """ + ], + macrocallback: [ + zero_arg: "@«macrocallback my_cb() :: boolean()»", + one_arg: "@«macrocallback my_cb(foo :: integer) :: String.t()»", + multiple_args: + "@«macrocallback my_cb(foo :: integer, bar:: String.t()) :: [pos_integer()]»", + multiple_line: """ + @«macrocallback my_cb( + foo :: String.t(), + bar :: pos_integer()) :: pos_integer()» + """ + ] + ], + comment: [ + start_of_line: "«# IO.puts»", + end_of_line: "IO.puts(thing) «# IO.puts»" + ], + doc: [ + empty: ~S[@«doc ""»], + false: "@«doc false»", + single_line: ~S[@«doc "this is my doc»"], + multi_line: ~S[@«doc """ + This is the doc + """» + ] + ], + function_capture: [ + local_arity: ~q[&«my_fun/1»], + local_argument: ~q[&«my_fun(arg, &1)»], + remote_arity: ~q[&«Remote.my_fun/1»], + remote_argument: ~q[&«Remote.my_fun(arg, &1)»] + ], + import: [ + single: ~q(import« MyModule»), + chain: ~q(import« MyModule.SubModule»), + only: [ + single_line: ~q(import« OtherModule, only: [something: 3, other_thing: 2]»), + multi_line: ~q(import« OtherModule, only: »[ + something: 3, + other_thing: 2 + ]) + ], + except: [ + single_line: ~q(import« OtherModule, except: [something: 3, other_thing: 2]»), + multi_line: ~q(import« OtherModule, except: »[ + something: 3, + other_thing: 2 + ]) + ] + ], + keyword: [ + single_line: + ~q(«string: "value", atom: :value2, int: 6, float: 2.0, list: [1, 2], tuple: {3, 4}»), + multi_line: ~q( + [« + string: "value", + atom: :value2, + int: 6, + float: 2.0, + list: [1, 2], + tuple: {3, 4} + »]) + ], + map: [ + single_line: + ~q(%{«string: "value", atom: :value2, int: 6 float: 2.0, list: [1, 2], tuple: {3, 4}}») + ], + module_doc: [ + empty: ~S[@«moduledoc ""»], + false: "@«moduledoc false»", + single_line: ~S[@«moduledoc "this is my moduledoc»"], + multi_line: ~S[@«moduledoc """ + This is the moduledoc + """» + ] + ], + module_attribute: [ + single_line: "@«attr 45»", + multi_line_pipe: """ + @«attr other_thing» + |> «Enum.shuffle()» + |> «Enum.max()» + """, + multi_line_list: """ + @«attrs [» + «:foo», + «:bar», + «:baz» + ] + """ + ], + pipe: [ + one_line: ~q[foo |> «bar»() |> «RemoteCall.fun»() |> «:remote_erlang.call»()], + multi_line: ~q[ + document + |> «local_call»() + |> «RemoteModule.call»() + |> «:remote_erlang.call»() + ] + ], + require: [ + single: ~q(require« MyModule»), + chain: ~q(require« MyModule.Submodule») + ], + spec: [ + simple_function: ~q{@spec« function_name(String.t) :: any()»}, + multi_line: ~q{ + @spec «on_multiple_lines :: integer()» + | «String.t()» + | «something()» + }, + or_type: ~q{@spec« my_func() :: :yours | :mine | :the_truth»} + ], + struct_field_key: [ + simple: ~q[%User{«foo:» 3,« bar:» 8}] + ], + struct_field_value: [ + single_line: ~q[%User{field_name:« 3», next_name:« :atom»}] + ], + struct_fields: [ + one_line: [ + empty: ~q[%User{«»}], + simple: ~q[%User{«field_name: 3, other_name: 9»}] + ], + multi_line: [ + simple: ~q[ + %Struct{« + amount: 1, + kind: :tomatoes» + } + ] + ] + ], + strings: [ + literal: ~q["«this is a string»"], + interpolation: [ + variable: ~S["«before »#{interp}« after»"], + math: ~S["«before »#{3 + 1}« after»"], + function_call: ~S["«before »#{my_fun(arg)}« after»"], + multiple: ~S["«before »#{first}« middle »#{second}« after»"] + ], + heredocs: [ + simple: ~S[ + """ + «This is in the heredoc + It's multiple lines» + """ + ], + interpolation: ~S[ + """ + «This is the heredoc + #{something} is interpolated» + """ + ] + ], + sigils: [ + s: [ + single_line: ~S[ + ~s/«this is a string»/ + ], + multi_line: ~S[ + ~s/« + this is a string + that spans + many lines + »/ + ] + ], + S: [ + single_line: ~S[ + ~S/«this is a string»/ + ], + multi_line: ~S[ + ~S/« + this is a string + that spans + many lines + »/ + ] + ] + ] + ], + struct_reference: [ + single_line: ~q(%U«ser»{#{keys_and_values()}}), + nested: ~q[%U«ser»{account: %A«ccount»{#{keys_and_values()}}}] + ], + type: [ + private: ~q[@typep« my_type :: integer()»], + opaque: ~q[@opaque« opaque :: integer()»], + single_line: [ + simple: ~q[@type« my_type :: integer()»], + composite: ~q[@type« my_type :: :foo | :bar | :baz»] + ], + multi_line: [ + composite: ~q[ + @type« multi_line ::» + «integer()» + |« String.t()» + |« Something.t()» + ] + ] + ], + use: [ + simple: ~q(use« SomeModule»), + params: [ + single_line: ~q(use« SomeModule, param: 3, other_param: :doggy»), + multi_line: ~q( + use «SomeModule, »[ + with: :features, + that_are: :great + ] + ) + ] + ] + ] + end + + def get do + flatten(suite()) + end + + defp flatten(keyword) do + keyword + |> do_flatten([], []) + |> Enum.map(fn {path, value} -> {Enum.reverse(path), value} end) + end + + defp do_flatten(keyword, prefix, acc) do + Enum.reduce(keyword, acc, fn + {k, v}, acc when is_list(v) -> + do_flatten(v, [k | prefix], acc) + + {k, v}, acc -> + [{[k | prefix], v} | acc] + end) + end + + defp list_literal do + ~q([:atom, 1, 2.0, "string", %{a: 1, b: 2}, [1, 2, 3], {1, 2}]) + end + + defp map_literal do + ~q(%{foo: 3, bar: 6}) + end + + defp keyword_literal do + ~q([key_1: 3, key_2: #{list_literal()}]) + end + + defp tuple_litral do + ~q({:atom, 1, 2.0, "string", %{a: 1, b: 2}, [1, 2, 3], {1, 2}}) + end + + defp keys_and_values do + ~q(string: "value", atom: :value2, int: 6 float: 2.0, keyword: #{keyword_literal()} map: #{map_literal()}, list: #{list_literal()}, tuple: #{tuple_litral()}) + end +end diff --git a/forge/test/support/lexical/test/variations.ex b/forge/test/support/lexical/test/variations.ex new file mode 100644 index 00000000..febe54d3 --- /dev/null +++ b/forge/test/support/lexical/test/variations.ex @@ -0,0 +1,50 @@ +defmodule Forge.Test.Variations do + def wrap_with(:nothing, text) do + text + end + + def wrap_with(:match, text) do + """ + x = #{text} + """ + end + + def wrap_with(:module, text) do + """ + defmodule MyModule do + #{text} + end + """ + end + + def wrap_with(:function_body, text) do + body = """ + def func do + #{text} + end + """ + + wrap_with(:module, body) + end + + def wrap_with(:function_arguments, text) do + args = """ + def func(#{text}) do + end + """ + + wrap_with(:module, args) + end + + def wrap_with(:comprehension_generator, text) do + """ + for x <- #{text} do + x + end + """ + end + + def wrap_with(:function_call, text) do + "Enum.map(things, #{text})" + end +end diff --git a/forge/test/test_helper.exs b/forge/test/test_helper.exs new file mode 100644 index 00000000..db057cfd --- /dev/null +++ b/forge/test/test_helper.exs @@ -0,0 +1,2 @@ +Application.ensure_all_started(:snowflake) +ExUnit.start()