138 lines
3.8 KiB
Elixir
138 lines
3.8 KiB
Elixir
defmodule Lytlang do
|
|
@root_module :Lytlang
|
|
|
|
def eval(string) do
|
|
{value, _} =
|
|
string
|
|
|> from_lytlang()
|
|
|> Code.eval_quoted()
|
|
|
|
value
|
|
end
|
|
|
|
def from_lytlang(string, binding \\ [], opts \\ []) do
|
|
string
|
|
|> String.to_charlist()
|
|
|> tokenize()
|
|
|> parse()
|
|
|> to_ast_node(binding, opts)
|
|
|> to_elixir_ast(opts)
|
|
end
|
|
|
|
def tokenize(string) do
|
|
{:ok, tokens, _} =
|
|
:lytlang_lexer.string(string)
|
|
|> IO.inspect(label: "Tokens")
|
|
|
|
tokens
|
|
end
|
|
|
|
def parse(tokens) do
|
|
{:ok, tree} =
|
|
:lytlang_parser.parse(tokens)
|
|
|> IO.inspect(label: "Parsed")
|
|
|
|
tree
|
|
end
|
|
|
|
@type astnode :: {any, {keyword, keyword, keyword}, list}
|
|
@type ex_astnode :: {any, keyword, any}
|
|
|
|
# @spec to_elixir_ast(astnode, keyword) :: ex_astnode
|
|
def to_elixir_ast(astnode, opts \\ [])
|
|
|
|
def to_elixir_ast(s, opts) when is_list(s) do
|
|
Enum.map(s, fn node ->
|
|
to_elixir_ast(node, opts)
|
|
end)
|
|
end
|
|
|
|
def to_elixir_ast({{:literal, expr}, {_meta, _binding, _ast_opts}, _leaves}, _opts) do
|
|
expr
|
|
|> IO.inspect(label: "EX AST")
|
|
end
|
|
|
|
def to_elixir_ast({s, {_meta, binding, _ast_opts}, leaves}, _opts) do
|
|
{s, binding, to_elixir_ast(leaves)}
|
|
|> IO.inspect(label: "EX AST")
|
|
end
|
|
|
|
@spec to_ast_node(any, keyword, keyword) :: astnode
|
|
def to_ast_node(ast, binding \\ [], opts \\ [])
|
|
|
|
def to_ast_node([], binding, opts), do: {[], {binding, opts}}
|
|
|
|
def to_ast_node(expr_list, binding, opts) when is_list(expr_list) do
|
|
Enum.reduce(expr_list, {nil, {[], binding, opts}, []}, fn expr,
|
|
{_s, {_meta, binding, opts},
|
|
_operands} ->
|
|
{s, {nmeta, nbinding, nopts}, operands} = to_ast_node(expr, binding, opts)
|
|
|
|
{s, {nmeta, Keyword.merge(binding, nbinding), Keyword.merge(opts, nopts)}, operands}
|
|
end)
|
|
end
|
|
|
|
def to_ast_node({:list_op, line, op, operands}, binding, opts) when is_list(operands) do
|
|
{op, {[line: line], binding, opts},
|
|
[Enum.map(operands, fn o -> to_ast_node(o, binding, opts) end)]}
|
|
end
|
|
|
|
def to_ast_node({:binary_op, line, op, left, right}, binding, opts) do
|
|
{op, {[line: line], binding, opts}, [to_ast_node(left), to_ast_node(right)]}
|
|
end
|
|
|
|
def to_ast_node({:unary_op, line, op, left}, binding, opts) do
|
|
{op, {[line: line], binding, opts}, [to_ast_node(left)]}
|
|
end
|
|
|
|
def to_ast_node({:var, line, left} = _expr, binding, opts) do
|
|
# TODO: probably need to look in bindings? or shadowing so maybe not?
|
|
to_ast_node({:unary_op, line, left, {:literal, line, @root_module}}, binding, opts)
|
|
end
|
|
|
|
def to_ast_node({:match, line, left, right} = _expr, binding, opts) do
|
|
to_ast_node({:binary_op, line, :=, left, right}, binding, opts)
|
|
end
|
|
|
|
def to_ast_node({:integer, line, val} = _expr, binding, opts) do
|
|
to_ast_node({:literal, line, val}, binding, opts)
|
|
end
|
|
|
|
def to_ast_node({:literal, line, val} = _expr, binding, opts) do
|
|
{{:literal, val}, {[line: line], binding, opts}, []}
|
|
end
|
|
end
|
|
|
|
"""
|
|
-module(elixir).
|
|
-export([eval/1, from_elixir/1, from_erlang/1]).
|
|
|
|
eval(String) ->
|
|
{value, Value, _} = erl_eval:expr(from_elixir(String), []),
|
|
Value.
|
|
|
|
% Temporary to aid debugging
|
|
from_elixir(String) ->
|
|
transform(parse(String)).
|
|
|
|
% Temporary to aid debugging
|
|
from_erlang(String) ->
|
|
{ok, Tokens, _} = erl_scan:string(String),
|
|
{ok, [Form]} = erl_parse:parse_exprs(Tokens),
|
|
Form.
|
|
|
|
parse(String) ->
|
|
{ok, Tokens, _} = elixir_lexer:string(String),
|
|
{ok, ParseTree} = elixir_parser:parse(Tokens),
|
|
ParseTree.
|
|
|
|
transform({ binary_op, Line, Op, Left, Right }) ->
|
|
{op, Line, Op, transform(Left), transform(Right)};
|
|
|
|
transform({ unary_op, Line, Op, Right }) ->
|
|
{op, Line, Op, transform(Right)};
|
|
|
|
|
|
transform({ integer, _, _ } = Expr) -> Expr.
|
|
"""
|